ਪਾਕਾਸ - ਲਾਈਨ ਵਿੱਚ ਸਤਰ ਓਪਰੇਟਰ

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

ਪਾਸਕਲ ਵਿਚ ਕਿਹੜੀ ਇਕ ਲਾਈਨ ਹੈ?

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

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

ਸਤਰ ਡਾਟਾ ਕਿਸਮ

ਸਟ੍ਰਿੰਗ ਟਾਈਪ ਸਤਰ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਹੈ. ਪਾਸਕਲ ਪ੍ਰੋਗਰਾਮਰ ਨੂੰ ਅੱਖਰਾਂ ਦੀ ਅਸਲ ਸੰਖਿਆ ਨਿਸ਼ਚਿਤ ਕਰਨ ਜਾਂ ਉਸਦੀ ਡਿਫੌਲਟ ਲੰਬਾਈ ਨੂੰ ਛੱਡਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ - ਇਸ ਸਥਿਤੀ ਵਿੱਚ ਇਹ 255 ਦੇ ਬਰਾਬਰ ਹੋ ਜਾਵੇਗਾ. ਇੱਕੋ ਆਰਗੂਮੈਂਟ ਦੀ ਸੂਚੀ ਦੇ ਬਾਅਦ ਸਤਰ ਵੇਰੀਏਬਲ ਘੋਸ਼ਿਤ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਕੋਲੋਨ, ਸਤਰ ਦੇ ਬਾਅਦ ਇੱਕ ਸ਼ਬਦ ਨਿਸ਼ਚਿਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਅਤੇ, ਜੇ ਲੋੜ ਹੋਵੇ, ਲਾਈਨ ਹੇਠਾਂ ਉਦਾਹਰਨ ਵਿੱਚ, ਸਟ੍ਰਿੰਗ "str" ਨੂੰ 10 ਅੱਖਰਾਂ ਦੀ ਲੰਬਾਈ ਦੇ ਨਾਲ ਨਿਸ਼ਚਿਤ ਕੀਤਾ ਗਿਆ ਹੈ:

Var str: ਸਤਰ [10]

ਪਾਕਾਲ ਸਟ੍ਰਿੰਗ ਪ੍ਰੋਗਰਾਮ ਦੇ ਕੋਡ ਵਿੱਚ, ਤੁਸੀਂ ਕੋਈ ਵੀ ਮੁੱਲ ਸੈਟ ਕਰ ਸਕਦੇ ਹੋ - ਤੁਹਾਨੂੰ ਸਿਰਫ ਉਹਨਾਂ ਨੂੰ ਸਿੰਗਲ ਕੋਟਸ ਵਿੱਚ ਜੋੜਨ ਦੀ ਲੋੜ ਹੈ

ਸਤਰ ਕਾਰਵਾਈਆਂ

ਭਾਸ਼ਾ 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹੋਏ, ਕਾਰਵਾਈਆਂ ਦੀ ਗਿਣਤੀ ਜਿਸ ਨਾਲ ਸਤਰ ਕੰਮ ਕਰ ਸਕਦੀ ਹੈ ਨਿਰਧਾਰਤ ਕੀਤੀ ਜਾਂਦੀ ਹੈ. ਪਾਸਕਲ ਤੁਹਾਨੂੰ ਸਤਰ ਡਾਟਾ ਦੀ ਤੁਲਨਾ ਕਰਨ ਅਤੇ ਰਲਵੇਂ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ.

ਇੱਕ ਅਭਿਆਸ (ਦੂਜੇ ਸ਼ਬਦਾਂ ਵਿੱਚ, ਸਮਕਾਲੀਨ ਜਾਂ ਸਮਕਾਲੀਨ) ਕਈ ਕਤਾਰਾਂ ਨੂੰ ਇੱਕ ਵਿੱਚ ਮਿਲਾਉਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ. ਇਸ ਨੂੰ ਜੋੜ ਦੇ ਨਿਸ਼ਾਨ ਦੁਆਰਾ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਹੈ: "+". ਇਸਦੀ ਸਹਾਇਤਾ ਨਾਲ, ਤੁਸੀਂ ਇੱਕ ਅਜਿਹੀ ਲਾਈਨ ਬਣਾ ਸਕਦੇ ਹੋ ਜਿਸ ਵਿੱਚ ਕਈ ਸਮੀਕਰਣ, ਸਥਿਰ ਅਤੇ ਵੇਰੀਏਬਲ ਸ਼ਾਮਿਲ ਹਨ.

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

ਪਾਸਕਲ ਵਿੱਚ ਸਮਰਥਤ ਇੱਕ ਹੋਰ ਓਪਰੇਸ਼ਨ ਸਤਰ ਦੀ ਤੁਲਨਾ ਜਾਂ ਸਤਰ ਦੀ ਤੁਲਨਾ ਕਰਦੇ ਹਨ. ਸਭ ਤੋਂ ਸਰਲ ਗਣਿਤ ਸੰਕੇਤ ਇਸ ਲਈ ਵੀ ਵਰਤੇ ਜਾਂਦੇ ਹਨ:

• ਸਮਾਨਤਾ (=);
• ਹੋਰ / ਘੱਟ (> ਅਤੇ <);
• ਅਸਮਾਨਤਾਵਾਂ (<>);
• ਅਤੇ (> = ਅਤੇ <=) ਦੇ ਬਰਾਬਰ ਜਾਂ ਇਸ ਤੋਂ ਬਰਾਬਰ ਅਤੇ ਇਸ ਤੋਂ ਘੱਟ ਜਾਂ ਬਰਾਬਰ ਹੈ.

ਰਿਲੇਸ਼ਨਲ ਓਪਰੇਸ਼ਨ ਦੇ ਸਿੱਟੇ ਵਜੋਂ ਸੱਚੀ ਜਾਂ ਝੂਠ ਦਾ ਬੂਲੀਅਨ ਮੁੱਲ ਵਾਪਸ ਆਉਂਦਾ ਹੈ.

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

ਸਤਰ ਵੇਰੀਏਬਲਾਂ ਦੇ ਫੰਕਸ਼ਨ

ਜਿਵੇਂ ਕਿ ਕਿਸੇ ਵੀ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਭਾਸ਼ਾ ਵਿੱਚ, ਪਾਕਾਲ ਵਿੱਚ ਬਹੁਤ ਸਾਰੇ ਫੰਕਸ਼ਨ ਹਨ ਜੋ ਇੱਕ ਸਤਰ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਨ. ਪਾਸਕਲ ਤੁਹਾਨੂੰ ਇੱਕ ਵੈਰੀਏਬਲ ਦਾ ਇੱਕ ਹਿੱਸਾ ਕਾਪੀ ਕਰਨ, ਇਕ-ਦੂਜੇ ਦੇ ਵਿਚਕਾਰ ਕਈ ਲਾਈਨਾਂ ਨੂੰ ਜੋੜਨ, ਸਬ-ਸਤਰ ਲੱਭਣ ਅਤੇ ਉਸਦੀ ਲੰਬਾਈ ਦਾ ਹਿਸਾਬ ਕਰਨ ਲਈ ਸਹਾਇਕ ਹੈ. ਇਹ ਹੇਠ ਦਿੱਤੇ 4 ਕਾਰਜਾਂ ਦੁਆਰਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ:

• ਲਾਈਨ ਦੇ ਇੱਕ ਹਿੱਸੇ ਨੂੰ ਕਾਪੀ ਕਰਨ ਲਈ, ਕਾਪੀ ਫੰਕਸ਼ਨ ਜ਼ਿੰਮੇਵਾਰ ਹੈ. ਇਸ ਵਿੱਚ ਤਿੰਨ ਪੈਰਾਮੀਟਰ ਹਨ- ਸਤਰ ਜਾਂ ਵੇਰੀਏਬਲ ਦਾ ਨਾਮ, ਸ਼ੁਰੂ ਦੀ ਸਥਿਤੀ ਅਤੇ ਨਕਲ ਕਰਨ ਲਈ ਅੱਖਰਾਂ ਦੀ ਸੰਖਿਆ:

ਕਾਪੀ (ਐਸ, ਪੋਜ਼, ਐਨ) - ਇੱਥੇ S ਇੱਕ ਸਤਰ ਵੇਰੀਬਲ ਹੈ, ਅਤੇ ਪਜ਼ ਅਤੇ n ਪੂਰਨ ਅੰਕ ਹਨ.

• "+" ਚਿੰਨ੍ਹ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਕੰਟੈਕਟੇਟਿੰਗ ਸਟ੍ਰਿੰਗ ਤੋਂ ਇਲਾਵਾ, ਤੁਸੀਂ ਇਸ ਕਾਰਵਾਈ ਨੂੰ ਹੋਰ ਸੌਖੀ ਤਰੀਕੇ ਨਾਲ ਕਰਨ ਲਈ ਕੰਕੈਟ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ. ਇਸ ਦੇ ਆਰਗੂਮਿੰਟ ਦੇ ਤੌਰ ਤੇ, ਸਾਰੇ ਸਤਰ ਅਤੇ ਨਿਸ਼ਾਨ ਪ੍ਰਗਟਾਵਾਂ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਜਿਹਨਾਂ ਨੂੰ ਇਕੱਠਾ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ:

ਕਨੈਕਟ (ਐਸ 1, ਐਸ 2 ...).

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

ਲੰਬਾਈ (str)

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

ਪੋਜ (ਸਬਸ, ਐਸ)

ਪਾਕਾਲ ਵਿਚ ਸਟ੍ਰਿੰਗ ਲਈ ਪ੍ਰਕਿਰਿਆ

ਪਾਸਕਲ ਵਿਚ ਵਰਤੇ ਜਾਣ ਵਾਲੇ ਮਿਆਰੀ ਪ੍ਰਕਿਰਿਆ ਕੇਵਲ ਦੋ ਹਨ. ਸਤਰ ਵਿੱਚ ਅੱਖਰਾਂ ਦੀ ਇੱਕ ਸਤਰ ਦਾਖਲ ਕਰਨ ਲਈ ਪਹਿਲੇ ਇੱਕ ਨੂੰ ਕੁਝ ਸਬਸਟ੍ਰਿੰਗ ਅਤੇ ਦੂਜੀ ਨੂੰ ਮਿਟਾਉਣ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ.

ਇਸ ਲਈ, ਪ੍ਰਕਿਰਿਆ ਹਟਾਓ ਚੁਣੀ ਹੋਈ ਲਕੀਰ ਵਿੱਚੋਂ ਨਿਸ਼ਚਤ ਡਿਲੀਟ, ਨਿਸ਼ਚਤ ਪੋਜੀਸ਼ਨ ਤੋਂ, ਅੱਖਰਾਂ ਦੀ ਨਿਸ਼ਚਿਤ ਸੰਖਿਆ ਤੋਂ ਸਬਥਿਰੰਗ. ਇਹ ਮਾਪਦੰਡ ਹਰ ਇੱਕ ਇਹ ਕਿਰਿਆ ਦੀ ਦਲੀਲ ਹੈ:

ਮਿਟਾਓ (ਐਸ, ਪੋਜ਼, ਐਨ).

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

ਸੰਮਿਲਿਤ ਕਰੋ (ਸਬ ਐਸ, ਐਸ, ਪੌਜ਼).

ਸਟ੍ਰਿੰਗਸ ਤੋਂ ਡਾਟਾ ਟਾਈਪ ਬਦਲਣਾ

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

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

• ਉਲਟਾ ਓਪਰੇਸ਼ਨ ਕਰਨ ਲਈ - ਨੰਬਰ ਇੱਕ ਸਤਰ ਵਿੱਚ ਬਦਲੋ - ਤੁਹਾਨੂੰ ਫਲੋਟ-ਟੂ ਅੰਕ ਨੰਬਰ ਅਤੇ ਪੂਰਨ ਅੰਕ ਮੁੱਲਾਂ ਲਈ IntToStr ਲਈ ਫਲੋਟਟੋਸਟਰ ਪ੍ਰਕਿਰਿਆਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਲੋੜ ਹੈ.
• ਕਿਸੇ ਕਿਸਮ ਨੂੰ ਬਦਲਣ ਦਾ ਇਕ ਹੋਰ ਤਰੀਕਾ ਹੈ ਵਿਸ਼ੇਸ਼ ਪ੍ਰਕਿਰਿਆਵਾਂ ਦਾ ਇਸਤੇਮਾਲ ਕਰਨਾ, ਜਿਸ ਲਈ ਤੁਹਾਨੂੰ ਸ਼ੁਰੂ ਜਾਂ ਅੰਤ ਡਾਟਾ ਟਾਈਪ, ਸਟਰ ਅਤੇ ਵੈਲ ਨੂੰ ਜਾਣਨ ਦੀ ਜ਼ਰੂਰਤ ਨਹੀਂ ਹੈ. ਪਹਿਲਾਂ ਇੱਕ ਸੰਖਿਆ ਤੋਂ ਇੱਕ ਸਤਰ ਵਿੱਚ ਅਨੁਵਾਦ ਤਿਆਰ ਕਰਦਾ ਹੈ ਅਤੇ ਇੱਕ ਆਰਗੂਲੇਸ਼ਨ ਦੇ ਤੌਰ ਤੇ ਦੋ ਮੁੱਲ ਹੁੰਦੇ ਹਨ - ਸਤਰ ਦੇ ਨਾਮ ਨਾਲ ਇੱਕ ਬੀਜ ਅਤੇ ਇੱਕ ਵੇਰੀਏਬਲ. ਦੂਸਰਾ ਤਰੀਕਾ ਰਿਵਰਸ ਅਪਰੇਸ਼ਨ ਕਰਦਾ ਹੈ, ਅਤੇ ਇੱਕ ਹੋਰ ਪੈਰਾਮੀਟਰ - ਅੰਕੀ ਅਤੇ ਸਤਰ ਮੁੱਲ ਤੋਂ ਇਲਾਵਾ, ਪ੍ਰਕਿਰਿਆ ਇੱਕ ਕੋਡ ਮੁਹੱਈਆ ਕਰਦੀ ਹੈ ਜੋ ਕਿ ਪਰਿਵਰਤਨ ਦੀ ਸ਼ੁੱਧਤਾ ਦਾ ਸੰਕੇਤ ਹੈ. ਇਸ ਲਈ, ਉਦਾਹਰਣ ਵਜੋਂ, ਇਕ ਅੰਕ ਅੰਕ ਨੂੰ ਇਕ ਪੂਰਨ ਅੰਕ ਵਿਚ ਲਿਖਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਿਆਂ, ਕੋਡ ਉਸ ਸੰਕੇਤ ਦੀ ਗਿਣਤੀ ਦਿਖਾਏਗਾ ਜਿਸ ਉੱਤੇ ਅਸਫਲਤਾ ਆਈ ਹੈ, ਅਤੇ ਸਹੀ ਤਬਦੀਲੀ ਨਾਲ, ਇਸਦਾ ਮੁੱਲ 0 ਹੋਵੇਗਾ.