ਜਾਵਾਸਕਰਿਪਟ-ਐਰੇ ਅਤੇ ਇਸ ਦੇ ਰਚਨਾ ਨੂੰ. ਜਾਵਾਸਕਰਿਪਟ ਐਰੇ ਬਾਰੇ ਸਾਰੇ

ਇਸ ਲੇਖ ਵਿਚ ਸਾਨੂੰ ਜਾਵਾਸਕਰਿਪਟ-ਐਰੇ, ਇਸ ਦੇ ਭਾਗ 'ਤੇ ਦਿਖਾਈ ਦੇਵੇਗਾ. JavaScript ਨੂੰ ਇਕ ਮੁਕੰਮਲ ਦ੍ਰਿਸ਼-ਅਧਾਰਿਤ ਪਰੋਗਰਾਮਿੰਗ ਲਈ ਤਿਆਰ ਭਾਸ਼ਾ ਹੈ. ਅਸਲ ਵਿਚ, ਇਸ ਨੂੰ ECMAScript ਭਾਸ਼ਾ (ਮਿਆਰੀ ECMA-262) ਲਾਗੂ ਕਰਦਾ ਹੈ.

ਜਾਵਾਸਕਰਿਪਟ ਦੇ? ਇਹ ਕ੍ਰਮ ਨੂੰ ਵਿਸ਼ੇ ਕਾਰਜ ਨੂੰ ਕਰਨ ਲਈ ਪ੍ਰੋਗਰਾਮ ਦੇ ਮਾਰਗ ਦਾ ਪਤਾ ਕਰਨ ਲਈ ਸ਼ਾਮਿਲ ਭਾਸ਼ਾ ਦੇ ਤੌਰ ਤੇ ਵਰਤਿਆ ਗਿਆ ਹੈ. ਇਹ ਬਰਾਊਜ਼ਰ ਵਿੱਚ ਪਾਇਆ ਜਾ ਸਕਦਾ ਹੈ: ਇਸ ਨੂੰ ਇੱਕ ਸਕਰਿਪਟਿੰਗ ਭਾਸ਼ਾ ਹੈ, ਜੋ ਕਿ ਵੈੱਬ ਪੰਨੇ ਪਰਸਪਰ ਦਿੰਦਾ ਹੈ ਦੇ ਰੂਪ ਵਿੱਚ ਵਰਤਿਆ ਗਿਆ ਹੈ.

ਇਸ ਉਤਪਾਦ ਦੇ ਮੁੱਖ ਭਿਨ ਫੀਚਰ ਗਤੀਸ਼ੀਲ ਅਤੇ ਕਮਜ਼ੋਰ ਟਾਈਪਿੰਗ, avtoupravlenie ਮੈਮੋਰੀ ਆਦਰਸ਼ ਪ੍ਰੋਗਰਾਮਿੰਗ ਫੰਕਸ਼ਨ ਹੈ, ਜੋ ਕਿ ਪਹਿਲੀ ਡਿਸਚਾਰਜ ਦੀ ਇਕਾਈ ਹਨ.

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

ਇਹ ਨੋਟ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ, ਜੋ ਕਿ ਜਾਵਾ-- ਓਰੇਕਲ ਕਾਰਪੋਰੇਸ਼ਨ ਗਰੁੱਪ ਦਾ ਰਜਿਸਟ੍ਰਡ ਟ੍ਰੇਡਮਾਰਕ.

ਇੱਕ ਐਰੇ ਕੀ ਹੈ?

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

ਇਸ ਦੇ ਨਾਲ, ਜਾਵਾ--ਐਰੇ ਗਤੀਸ਼ੀਲ ਹੈ, ਅਤੇ ਇਸ ਨੂੰ ਕਿਹਾ ਗਿਆ ਹੈ, ਜੋ ਕਿ ਇੱਕ ਸਥਿਰ ਅਕਾਰ ਦਾ ਐਲਾਨ ਕੀਤਾ ਜਾ ਲੋੜ ਹੈ, ਨਾ. ਕਿਸੇ ਵੀ ਵੇਲੇ ਨਵ ਹਿੱਸੇ ਨੂੰ ਸ਼ਾਮਿਲ ਕਰਨ ਦੇ ਬਾਅਦ.

ਠੋਸ ਦੇ ਉਤਪਾਦਨ

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

• var ਖਾਲੀ = []; // ਖਾਲੀ ਐਰੇ;
• var numers = [4, 1, 2, 5]; // ਪੰਜ ਡਿਜ਼ੀਟਲ ਭਾਗ ਨਾਲ ਐਰੇ;
• var ਅੰਤਰ = [1.5, ਝੂਠੇ, «ਪਾਠ"]; // ਵੱਖ-ਵੱਖ ਕਿਸਮ ਦੇ ਤਿੰਨ ਤੱਤ ਨਾਲ ਐਰੇ.

ਇੱਕ ਨਿਯਮ ਦੇ ਤੌਰ ਤੇ, ਇਸ ਨੂੰ ਸਧਾਰਨ ਮੁੱਲ (ਕਤਾਰ ਹੈ ਅਤੇ ਨੰਬਰ) ਹੋਣ ਦੀ ਲੋੜ ਨਹੀ ਹੈ. ਇਸ ਵਿਚ ਇਹ ਵੀ ਕਿਸੇ ਵੀ ਹੋਰ ਸਮੀਕਰਨ ਹੈ, ਉਦਾਹਰਨ ਲਈ, ਇਕਾਈ ਲਿਟਰਲ, ਹੋਰ ਫੰਕਸ਼ਨ ਅਤੇ ਐਰੇ ਹੋ ਸਕਦਾ ਹੈ.

ਇੱਕ ਐਰੇ ਡਿਜ਼ਾਇਨਰ ਬਣਾਉਣ ਲਈ ਦੂਜਾ ਤਰੀਕਾ ਐਰੇ ਨੂੰ ਕਾਲ ਕਰਨ ਲਈ ਹੈ, (). ਉਸ ਨੂੰ ਤਿੰਨ ਢੰਗ ਦੇ ਇੱਕ ਨੂੰ ਸੱਦਾ ਕਰਨ ਲਈ:

• ਬਹਿਸ ਬਿਨਾ ਇੱਕ ਡਿਜ਼ਾਇਨਰ ਨੂੰ ਕਾਲ ਕਰੋ: var ਅ - ਨਵ ਐਰੇ (). ਇਹ ਇੱਕ ਖਾਲੀ ਅਸਲੀ [] ਇਕ ਖਾਲੀ ਐਰੇ ਬਰਾਬਰ ਦੀ ਰਚਨਾ ਲਈ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ.
• var ਅ = ਨਵ ਐਰੇ (1, 3, 5, 8, "ਲਾਈਨ», ਇਹ ਸੱਚ ਹੈ): Designer ਸਪਸ਼ਟ ਐਰੇ ਭਾਗ ਦੇ ਮੁੱਲ n ਨਿਰਧਾਰਿਤ ਕੀਤਾ ਹੈ. ਇਸ ਕੇਸ ਵਿੱਚ, ਡਿਜ਼ਾਇਨਰ ਬਹਿਸ ਹੈ, ਜੋ ਕਿ ਇੱਕ ਨਵ ਐਰੇ ਭਾਗ ਵਿੱਚ ਬਦਲ ਰਹੇ ਹਨ, ਦੀ ਸੂਚੀ ਪੇਸ਼ ਕੀਤੀ ਹੈ. ਆਰਗੂਮਿੰਟ ਐਰੇ ਨੂੰ ਲਿਖਿਆ ਹੈ, ਜਿੱਥੇ ਦੀ ਸਥਿਤੀ ਦਾ ਸੰਕੇਤ ਹੈ.
• ਨੂੰ ਹੋਰ ਨਿਰਧਾਰਤ ਮੁੱਲ ਲਈ ਸਕੋਪ ਪਰਿਭਾਸ਼ਿਤ. ਇਹ ਖੋਜ ਐਰੇ ਇੱਕ ਨੰਬਰ ਬਰੈਕਟ ਵਿਚ ਨੱਥੀ ਨਿਰਧਾਰਿਤ ਕਰਕੇ ਕੀਤਾ ਗਿਆ ਹੈ: var ਅ = ਨਵ ਐਰੇ (5). ਖੋਜ ਦੇ ਇਸ ਢੰਗ ਨੂੰ ਵੰਡ ਐਰੇ ਪੇਸ਼ਕਾਰੀ ਵਿੱਚ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਸੰਭਾਵਨਾ ਦੇ ਨਾਲ ਭਾਗ ਦੀ ਲੋੜ ਹੈ ਮਾਤਰਾ (ਜਿਸ ਦੀ ਹਰੇਕ ਪ੍ਰਭਾਸ਼ਿਤ ਦੇ ਤੌਰ ਤੇ ਸੂਚੀਬੱਧ ਹੈ) ਸ਼ਾਮਲ ਹੈ. ਇਹ ਫਾਰਮ ਆਮ ਤੌਰ 'ਤੇ ਪ੍ਰੀ-ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਜਾਵਾਸਕਰਿਪਟ-ਐਰੇ ਜਿਸ ਦੀ ਲੰਬਾਈ ਪੇਸ਼ਗੀ ਵਿੱਚ ਜਾਣਿਆ ਗਿਆ ਹੈ ਵਰਤਿਆ ਗਿਆ ਹੈ.

, ਰਿਕਾਰਡਿੰਗ ਨੂੰ ਪੜ੍ਹਨ ਅਤੇ ਐਰੇ ਦੇ ਵੇਰਵੇ ਨੂੰ ਸ਼ਾਮਿਲ

ਐਰੇ ਦੇ ਭਾਗ ਨੂੰ ਪ੍ਰਾਪਤ ਆਪਰੇਟਰ ਦੁਆਰਾ [] ਹੋ ਸਕਦਾ ਹੈ. ਤਰੀਕੇ ਨਾਲ ਕਰ ਕੇ, JavaScript ਵਿਚ ਭਾਗ ਦੇ ਸਾਰੇ, ਜ਼ੀਰੋ ਤੱਕ ਸ਼ੁਰੂ, ਹਨ. ਜ਼ਰੂਰੀ ਤੱਤ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ, ਵਿੱਚ ਇਸ ਦੇ ਨੰਬਰ ਨੂੰ ਲੱਗਦਾ ਹੈ ਵਰਗ ਬਰੈਕਟ. ਇੱਕ ਆਮ ਨਿਯਮ ਦੇ ਤੌਰ ਤੇ, ਇਕਾਈ ਨੂੰ ਤਬਦੀਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ. ਇੱਕ ਜਾਵਾ-ਐਰੇ ਨੂੰ ਸ਼ਾਮਿਲ ਕਰਨ ਲਈ, ਇਸ ਨੂੰ ਇੱਕ ਨਵ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਕਾਫੀ ਹੁੰਦਾ ਹੈ.

ਇਹ ਨੋਟ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ, ਜੋ ਕਿ ਜਾਵਾ-ਵਿਚ ਐਰੇ ਕਿਸੇ ਵੀ ਕਿਸਮ ਦੇ ਤੱਤ ਦੇ ਕਿਸੇ ਵੀ ਨੰਬਰ ਨੂੰ ਸਟੋਰ ਕਰ ਸਕਦੇ ਹੋ.

ਐਰੇ ਦੀ ਲੰਬਾਈ

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

ਇੱਕ ਐਰੇ ਦੇ ਫਾਈਨਲ ਭਾਗ ਨੂੰ ਵੇਖਾਉਣ ਲਈ, ਤੁਹਾਨੂੰ ਲੰਬਾਈ ਸੰਪਤੀ ਨੂੰ ਵਰਤ ਸਕਦੇ ਹੋ.

ਪਿਛਲੇ ਹਿੱਸੇ ਨੂੰ ਸੂਚੀ-ਪੱਤਰ ਨੂੰ ਇੱਕ ਐਰੇ ਦੇ ਆਕਾਰ ਨੂੰ ਵੱਧ ਘੱਟ ਹੈ. ਪੁੱਠੀ ਬਾਅਦ ਸਕਰੈਚ ਤੱਕ ਹਮੇਸ਼ਾ ਸ਼ੁਰੂ ਕਰ. ਓ, ਇਸ ਨੂੰ ਜਾਵਾ-! ਐਰੇ ਦੀ ਲੰਬਾਈ ਤੱਤ ਦੀ ਇਸ ਦੇ ਸਹੀ ਗਿਣਤੀ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ. ਇਸ ਲਈ, ਜੇ ਤੁਹਾਨੂੰ ਬਹੁਤ ਸਾਰੇ ਉਥੇ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਪਤਾ ਹੈ ਨਾ, ਪਰ ਤੁਹਾਨੂੰ ਐਰੇ ਦੇ ਫਾਈਨਲ ਤੱਤ ਨੂੰ ਚਾਲੂ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਇਸ ਨੂੰ ਜ਼ਰੂਰੀ ਰਿਕਾਰਡ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਹੈ: v.length - 1.

ਹਿੱਸੇ ਦੇ ਐਰੇ Iterate

ਬਹੁਤ ਹੀ ਅਕਸਰ, ਲੰਬਾਈ ਸੰਪਤੀ ਚੱਕਰ ਵਿੱਚ ਹਿੱਸੇ ਦੀ ਐਰੇ ਉੱਤੇ iterate ਕਰਨ ਲਈ ਵਰਤਿਆ ਗਿਆ ਹੈ:

• var ਫਲ = [ «ਸਟਰਾਬਰੀ", "ਆੜੂ," "ਸੇਬ," "ਕੇਲਾ"];
• (Var ਮੈਨੂੰ = 0; ਮੈਨੂੰ fruits.lenght <; i ++) ਲਈ;
• document.write (ਫਲ [i] + «...»).

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

ਚੱਕਰ ਨੂੰ ਵੀ ਕਈ ਵਾਰ ਭਾਗ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਵਰਤਿਆ ਗਿਆ ਹੈ.

ਵਾਧਾ ਅਤੇ truncation ਐਰੇ

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

foo.length = 0: ਕਾਫ਼ੀ ਬਸ ਦੇ ਤੌਰ ਤੇ ਐਰੇ ਨੂੰ ਸਾਫ਼ ਕਰੋ.

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

ਵੇਰਵੇ ਦੀ ਲੜੀ ਨੂੰ ਮਿਟਾਉਣ

ਹਟਾਓ ਆਪਰੇਟਰ ਪ੍ਰਭਾਸ਼ਿਤ ਕਰਨ ਲਈ ਲੜੀ ਭਾਗ ਨੂੰ ਦੱਸਦਾ ਹੈ, ਪਰ ਇਸ ਨੂੰ ਇਸ ਮਾਮਲੇ 'ਚ ਮੌਜੂਦ ਰਿਹਾ ਹੈ. ਤੁਹਾਨੂੰ ਐਰੇ ਦੇ JavaScript ਨੂੰ ਤੱਤ ਨੂੰ ਹਟਾਉਣ ਲਈ, ਇਸ ਲਈ ਹੈ, ਜੋ ਕਿ ਬਾਕੀ ਦਾ ਹਿੱਸਾ ਖਾਲੀ ਜਗ੍ਹਾ ਨੂੰ ਸ਼ਿਫਟ ਚਾਹੁੰਦੇ ਹੋ, ਤੁਹਾਨੂੰ ਤਰੀਕੇ ਐਰੇ ਦਾ ਅਨੁਮਾਨ ਕਰਨ ਦਾ ਇਸਤੇਮਾਲ ਕਰਨ ਦੀ ਲੋੜ ਹੈ. ਬੰਦ ਭਾਗ ਨੂੰ ਅਤੇ ਇੱਕ ਢੰਗ ਹੈ Splice () - - ਢੰਗ Array.shift () ਇੱਕ ਪਹਿਲੇ ਭਾਗ ਨੂੰ, ਪੌਪ () ਨੂੰ ਦੂਰ ਇੱਕ ਭਾਗ ਨੂੰ ਜ ਕਿਤੇ ਵੀ ਐਰੇ ਲੈਕੇ.

multidimensional ਐਰੇ

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

ਜੁੜਨਸ਼ੀਲ ਐਰੇ

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

ਆਉਟਪੁੱਟ ਐਰੇ

ਅਤੇ ਹੁਣ ਸਾਨੂੰ JavaScript ਨੂੰ ਸਿਸਟਮ ਵਿੱਚ ਪੜ੍ਹਾਈ ਕਰਨਗੇ? ਵਾਰਤਾਲਾਪ ਬਕਸੇ (ਸਕਰੀਨ 'ਤੇ) ਆਉਟਪੁੱਟ ਐਰੇ, ਦੇ ਨਾਲ ਨਾਲ ਐਰੇ ਭਾਗ ਦੀ ਆਊਟਪੁੱਟ ਮੁੱਲ.

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

ਸਫਾਈ

ਕ੍ਰਮ ਨੂੰ ਜਾਵਾਸਕਰਿਪਟ ਦੀ ਲੜੀ ਨੂੰ ਫਿਲਟਰ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਇਸ ਦੀ ਲੰਬਾਈ ਨੂੰ ਰੀਸੈੱਟ ਕਰਨ ਦੀ ਲੋੜ ਹੈ:

• var myArray = [1, 2, 5, 23];
• myArray.length = 0.

ਹੇਠ ਦਿੱਤੀ ਮੰਜ਼ਿਲ ਸਾਫ () ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ, ਇੱਕ ਫਰੇਮਵਰਕ, ਜਾਵਾ-ਪ੍ਰੋਟੋਟਾਈਪ ਵਿਚ ਪਤਾ ਲੱਗਦਾ ਹੈ:

• ਸਾਫ: ਫੰਕਸ਼ਨ () {;
• this.length = 0;
• ਇਸ ਨੂੰ ਵਾਪਸ;
• }.

ਸ਼ਾਮਿਲ ਅਤੇ ਭਾਗ ਨੂੰ ਹਟਾਉਣ

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

• ਜਦ ਮੈਨੂੰ ਇੱਕ ਡਿਜ਼ੀਟਲ ਅਣਜਾਣ ਵਿਸ਼ੇਸ਼ਤਾ ਨੂੰ ਸ਼ਾਮਿਲ ਕਰਨ, ਜੇ ਲੰਬਾਈ ਦੇ ਬਰਾਬਰ ਜ ਮੈਨੂੰ ਵੱਧ ਘੱਟ ਹੈ, ਦੀ ਲੰਬਾਈ i + 1 ਹੋ ਸਕਦੀ ਹੈ.
• ਤੁਹਾਨੂੰ ਹੇਠ ਦਿੱਤੇ ਪਗ਼ ਨੂੰ ਲੰਬਾਈ ਦੀ ਗੁਣਵੱਤਾ ਨੂੰ ਤਬਦੀਲ: ਜੇ ਨਿਰਧਾਰਤ ਮੁੱਲ ਜ਼ੀਰੋ ਵੱਧ ਘੱਟ ਹੈ, ਫਿਰ RangeError ਸੁੱਟ ਦਿੰਦਾ. ਸਾਰੇ ਅੰਕੀ ਗੁਣਵੱਤਾ ਇੰਡੈਕਸ ਹੈ, ਜੋ ਕਿ ਨਵ ਲੰਬਾਈ ਦੇ ਬਰਾਬਰ ਹੈ, ਅਤੇ ਵੱਧ ਹਨ ਖਤਮ ਕਰਦਾ ਹੈ.

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

unshift ਢੰਗ, ਸ਼ਿਫਟ, ਪੌਪ ਅਤੇ ਪੁਸ਼

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

ਕਾਰਜ ਨੂੰ ਐਰੇ ਪ੍ਰਸਾਰਿਤ ਇਕਾਈ ਦੇ ਅੰਤ ਧੱਕਣ ਲਈ ਭੇਜਦੀ ਹੈ. ਵਾਪਸ ਪੌਪ ਕਾਰਜ ਨੂੰ ਫਾਈਨਲ ਹਿੱਸੇ ਦੇ ਦਿੰਦਾ ਹੈ ਅਤੇ ਇਸ ਨੂੰ ਹਟਾ.

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

ਐਰੇ ਦੇ ਮੱਧ ਵਿੱਚ ਇਸ ਦੇ ਨਾਲ ਹੈ ਅਤੇ ਹਿੱਸੇ ਦੇ ਖਾਤਮੇ

ਤੁਹਾਨੂੰ JavaScript ਦੀ ਲੜੀ ਨੂੰ ਹਟਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤੁਹਾਨੂੰ ਕਰਨ ਦੀ ਲੋੜ ਹੈ? ਇਹ ਜਾਣਿਆ ਗਿਆ ਹੈ ਢੰਗ ਹੈ ਕਿ ਇੱਕ ਦਸਤਖਤ Splice Array.prototype.splice ਹੈ, ਜੋ ਕਿ.

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

ਅਸਲ ਵਿਚ, Splice ਢੰਗ ਨੂੰ ਵਰਤ ਕੇ, ਇਸ ਨੂੰ ਸੰਭਵ ਇੱਕ ਐਰੇ ਦੇ ਮੱਧ ਤੱਕ ਭਾਗ ਨੂੰ ਹਟਾਉਣ ਜ ਐਰੇ ਵਿੱਚ ਕਿਤੇ ਵੀ ਕਿਸੇ ਵੀ ਨੰਬਰ ਨੂੰ ਸ਼ਾਮਿਲ ਕਰਨ ਲਈ ਹੁੰਦਾ ਹੈ.

ਸਧਾਰਨ ਰੂਪ ਵਿੱਚ, ਜੇ ਇਹ ਜ਼ਰੂਰੀ ਹੈ i ਦਾ ਸੂਚਕ ਦੇ ਨਾਲ ਭਾਗ ਨੂੰ ਹਟਾਉਣ ਲਈ, ਐਰੇ ਪੈਰਾਮੀਟਰ i ਅਤੇ 1 ਨਾਲ Splice ਢੰਗ ਨੂੰ ਬੇਨਤੀ ਕਰਨ ਲਈ ਲੋੜ ਹੈ.

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

ਮਿਸਾਲ ਲਈ, ਫਾਇਰਫਾਕਸ, ਪਿਛਲੇ ਫਰਕ ਵਿਚ ਓਪੇਰਾ ਵਿੱਚ, ਐਰੇ ਦੇ ਅੰਤ ਵਿੱਚ ਅੱਗੇ ਸਾਰੇ ਵੇਰਵੇ ਸਫਾਰੀ ਅਤੇ Chrome ਵਿੱਚ ਹਟਾ ਦਿੱਤਾ ਜਾਵੇਗਾ.

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

ਕੁੰਜੀ

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

- ਪਤਾ ਕਰੋ (ਕੁੰਜੀ).

- ਪਾਓ (ਮੁੱਲ, ਕੁੰਜੀ).

- ਹਟਾਓ (ਕੁੰਜੀ).

ਇਹ ਮੰਨਿਆ ਜਾ ਰਿਹਾ ਹੈ, ਜੋ ਕਿ ਇੱਕ ਜੁੜਨਸ਼ੀਲ ਐਰੇ ਵਿੱਚ ਵੀ ਇਸੇ ਕੁੰਜੀ ਨਾਲ ਦੋ ਜੋੜੇ ਨੂੰ ਬਚਾ ਨਾ ਕਰ ਸਕਦੇ ਹੋ. K + ਆਦਿ ਦੇ ਇੱਕ ਜੋੜੇ ਨੂੰ ਵਿੱਚ ਕੁੰਜੀ-ਕਸ਼ਮੀਰ ਨਾਲ ਸਬੰਧਤ ਮੁੱਲ ਹੈ. Semantics ਅਤੇ ਇੱਥੇ ਅਜਿਹੇ ਐਰੇ ਦੇ ਵੱਖ-ਵੱਖ ਸਥਾਪਨ ਵਿੱਚ ਉਪਰੋਕਤ ਕਾਰਵਾਈ ਨਾਲ ਵੱਖ-ਵੱਖ ਹੋ ਸਕਦਾ ਹੈ.

ਇਸ ਲਈ, ਜਾਣਨ ਲਈ ਕਾਰਵਾਈ (ਕੁੰਜੀ) ਇੱਕ ਦਿੱਤੇ ਕੁੰਜੀ ਹੈ, ਜ ਇੱਕ ਖਾਸ ਇਕਾਈ UNDEF ਨਾਲ ਸੰਬੰਧਿਤ ਇੱਕ ਮੁੱਲ ਵਾਪਸ ਹੈ, ਭਾਵ ਹੈ ਕਿ ਮੁੱਲ ਇੱਕ ਦਿੱਤੇ ਕੁੰਜੀ, ਔਫਲਾਈਨ ਨਾਲ ਸੰਬੰਧਿਤ ਹੈ. ਦੋ ਹੋਰ ਕਾਰਵਾਈ (ਕਿ ਕੀ ਇਸ ਬਾਰੇ ਕਾਰਵਾਈ ਸਫਲ ਹੋਈ ਸੀ ਡਾਟਾ ਨੂੰ ਛੱਡ ਕੇ) ਨੂੰ ਵਾਪਸ ਨਾ ਕਰੋ.

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

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

ਇੱਕ ਜੁੜਨਸ਼ੀਲ ਐਰੇ ਦੀ ਇੱਕ ਉਦਾਹਰਨ ਇੱਕ ਟੈਲੀਫੋਨ ਡਾਇਰੈਕਟਰੀ ਦੇ ਤੌਰ ਤੇ ਸੇਵਾ ਕਰ ਸਕਦਾ ਹੈ. ਇਸ ਸਰੂਪ ਵਿੱਚ, ਮੁੱਲ "ਐੱਫ਼ ਸੈੱਟ ਕੀਤਾ ਗਿਆ ਹੈ IO + ਈ 'ਹੈ, ਅਤੇ ਕੁੰਜੀ - ਟੈਲੀਫੋਨ ਨੰਬਰ. ਇੱਕ ਫੋਨ ਨੰਬਰ ਇਕ ਮਾਸਟਰ ਹੈ, ਪਰ ਇੱਕ ਵਿਅਕਤੀ ਨੂੰ ਕਈ ਨੰਬਰ ਦੇ ਮਾਲਕ ਹੋ ਸਕਦਾ ਹੈ.

ਸਬੰਧਤ ਐਕਸ਼ਟੇਸ਼ਨ

ਇਹ ਨੋਟ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ, ਜੋ ਕਿ ਸਭ ਦੇ ਨਾਲ ਨਾਲ-ਜਾਣਿਆ ਇਕਸਟੈਨਸ਼ਨ ਹੇਠ ਸ਼ਾਮਲ ਹਨ:

• ਹਰ - «ਸੈਰ» ਸਭ ਜੋੜੇ ਸੰਭਾਲਦਾ ਹੈ.
• ਹਟਾਓ - ਸਭ ਇੰਦਰਾਜ਼ ਨੂੰ ਹਟਾਉਣ ਲਈ.
• MIN - ਘੱਟ ਕੁੰਜੀ ਦਾ ਮੁੱਲ ਦੇ ਨਾਲ ਇੱਕ ਜੋੜਾ ਦਾ ਪਤਾ ਕਰਨ ਲਈ.
• MAX - ਵੱਡੇ ਕੁੰਜੀ ਦਾ ਮੁੱਲ ਦੇ ਨਾਲ ਇੱਕ ਜੋੜਾ ਦਾ ਪਤਾ ਕਰਨ ਲਈ.

ਪਿਛਲੇ ਦੋ ਵਾਰ ਤੁਹਾਨੂੰ ਕੁੰਜੀ 'ਤੇ ਮੁਕਾਬਲੇ ਅਸਰ ਸੰਕੇਤ ਦੀ ਲੋੜ ਹੈ.

ਜੁੜਨਸ਼ੀਲ ਐਰੇ ਦੀ ਸਮਝ

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

ਵਧੀਆ ਜਾਣਿਆ ਲਾਗੂ ਕਰਨ, ਵੱਖ-ਵੱਖ ਖੋਜ ਰੁੱਖ 'ਤੇ ਅਧਾਰਿਤ ਹੈ. ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਖਾਸ ਪੜ੍ਹਨ ਕਮਰੇ STL C ++ ਭਾਸ਼ਾ ਟਰ੍ੇਲਰ ਨਕਸ਼ਾ ਵਿਚ ਕਾਲਾ ਅਤੇ mahogany ਦੇ ਆਧਾਰ 'ਤੇ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਹੈ. Ruby ਵਿੱਚ, ਸਟਾਈਲ, Tcl, ਪਾਇਥਨ ਹੈਸ਼ ਟੇਬਲ ਦੇ ਇੱਕ ਕਿਸਮ ਦੀ ਵਰਤਦਾ ਹੈ. ਹੋਰ ਲਾਗੂ ਕਰਨ ਹਨ.

ਆਮ ਤੌਰ 'ਤੇ, ਹਰ ਲਾਗੂ ਕਰਨ ਨੂੰ ਇਸ ਦੇ ਆਪਣੇ ਫ਼ਾਇਦੇ ਅਤੇ ਨੁਕਸਾਨ ਹਨ. ਇਹ ਜ਼ਰੂਰੀ ਹੈ ਕਿ ਸਾਰੇ ਤਿੰਨ ਓਪਰੇਸ਼ਨ ਔਸਤ 'ਤੇ ਪੂਰੇ ਹੋਏ ਸਨ, ਅਤੇ ਇਸ ਬਾਰੇ (ਲਾਗਇਨ n) ਸੂਖਮ ਸਭ ਮਿਆਦ' ਚ, ਜਿੱਥੇ n - ਮੌਜੂਦਾ ਗਿਣਤੀ ਪੈਰਾ ਨੂੰ ਬਚਾਉਣ ਲਈ. (ਕਾਲੇ ਅਤੇ ਲਾਲ ਰੁੱਖ ਸਮੇਤ) ਠੋਸ ਖੋਜ ਰੁੱਖ ਲਈ, ਇਸ ਹਾਲਤ ਸੰਤੁਸ਼ਟ ਹੈ.

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

ਤਰੀਕੇ ਨਾਲ ਕਰ ਕੇ, ਇਹ ਬਿਆਨ ਬੁਰਾ ਹੈ, ਜੋ ਕਿ ਇਸ ਦੇ ਆਧਾਰ 'ਤੇ ਇਸ ਨੂੰ ਤੇਜ਼ੀ ਨਾਲ ਵਾਧੂ ਕਾਰਵਾਈ ਕਰਨ MAX, ਮਿਨ ਕਰਨ ਲਈ ਅਸੰਭਵ ਹੈ ਹੈਸ਼, ਅਤੇ ਸਾਰੇ ਘੱਟਦੇ ਕ੍ਰਮ ਜ ਸਵਿੱਚ ਵੱਧਦੇ ਵਿਚ ਜੋੜੇ ਸੰਭਾਲਦਾ ਖੋਜ ਕਰਨ ਲਈ ਇੱਕ ਕਲਨ.