ਜੰਗਾਲ ਫਿਲਟਰ ਯੂ. ਟੀ. ਐੱਫ-8 ਅੱਖਰ'] ", 'ਜੰਗਾਲ ਫਿਲਟਰ ਯੂ. ਟੀ. ਐੱਫ-8 ਅੱਖਰ', ' [\'ਜੰਗਾਲ ਫਿਲਟਰ ਯੂ. ਟੀ. ਐੱਫ.-8 ਅੱਖਰ\', \'ਜੰਗਾਲ ਵਿੱਚ, ਤੁਸੀਂ ਬੰਦ ਕਰਨ ਦੇ ਨਾਲ-ਨਾਲ\' ਸਟਰ \'ਕਿਸਮ ਤੋਂ\' ਆਈਟਰ ਬਾਈਟਸ \'ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਯੂ. ਟੀ. ਐੱਫ.-8 ਅੱਖਰਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰ ਸਕਦੇ ਹੋ।ਜੋ ਬਾਈਟਾਂ ਨੂੰ ਉਹਨਾਂ ਦੇ ਯੂਨੀਕੋਡ ਕੋਡ ਬਿੰਦੂਆਂ ਦੇ ਅਧਾਰ ਉੱਤੇ ਫਿਲਟਰ ਕਰਦਾ ਹੈ। ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n "\'rust\\nfn main () {\\n Let s =" ¥ ". ਤੋਂ _ NAME _ 1 (); \\n\\n// ਨੂੰ ਬਦਲੋਯੂ. ਟੀ. ਐੱਫ.-8 ਇੰਕੋਡਿੰਗ ਨਾਲ ਬਾਈਟਾਂ ਨੂੰ ਨਾਮ _ 1 ਦਿਉ ਬਾਈਟ = s.as_bytes (). iter _ bytes (). ਕਲੋਨਡ (); \\n\\n// ਯੂਨੀਕੋਡ ਕੋਡ ਬਿੰਦੂਆਂ ਨਾਲ ਬਾਈਟਾਂ ਨੂੰ ਬਾਹਰ ਕੱਢੋASCII ਰੇਂਜ (0-127) \\n ਫਿਲਟਰ ਕੀਤੇ ਬਾਈਟਾਂ ਨੂੰ ਛੱਡੋਃ Vec <u8> = bytes.filter (|b। b> = 0x00 & & b <= 0x7f). ਇਕੱਠਾ ਕਰੋ (); \\n\\n// ਫਿਲਟਰ ਕੀਤੇ ਬਾਈਟਾਂ ਨੂੰ ਵਾਪਸ ਇੱਕ ਵਿੱਚ ਬਦਲੋਨਾਮ _ 1 ਨਾਲ ਯੂ. ਟੀ. ਐੱਫ.-8 ਇੰਕੋਡਿੰਗ \\ਨ ਪ੍ਰਿੰਟਲਨ! ("{}", ਨਾਮ _ 1:: ਤੋਂ _ ਯੂ. ਟੀ. ਐੱਫ. 8 _ ਲੌਸੀ (ਫਿਲਟਰਡ _ ਬਾਈਟਸ));// ਪ੍ਰਿੰਟਸ "¥" \\ਨ "\\ਨ" ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, ਅਸੀਂ ਪਹਿਲਾਂ ਨੂੰ ਬਦਲਦੇ ਹਾਂ\'to _ NAME _ 1\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ UTF-8 ਇੰਕੋਡਿੰਗ ਦੇ ਨਾਲ ਇੱਕ \'NAME _ 1\' ਲਈ ਨਾਮ _ 1 \'"¥"। ਫਿਰ ਅਸੀਂ\' ਦੇ ਬਾਈਟਾਂ ਉੱਤੇ ਇੱਕ ਇਟਰੇਟਰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ \'as _ bytes\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ।ਨਾਮ _ 1 ਨੂੰ UTF-8 ਇੰਕੋਡਿੰਗ ਨਾਲ। \\n\\n ਅਸੀਂ \'iter _ bytes\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ ਤਾਂ ਜੋ \'u8\' ਮੁੱਲਾਂ ਉੱਤੇ ਇਟਰੈਟਰ ਨੂੰ ਇੱਕ ਇਟਰੈਟਰ ਵਿੱਚ ਬਦਲਿਆ ਜਾ ਸਕੇ, ਜਿਸ ਦੀ ਵਰਤੋਂ ਅਸੀਂ ਫਿਰ ਨਾਲ ਕਰ ਸਕਦੇ ਹਾਂ।ASCII ਸੀਮਾ (0-127) ਤੋਂ ਬਾਹਰ ਯੂਨੀਕੋਡ ਕੋਡ ਬਿੰਦੂਆਂ ਵਾਲੇ ਬਾਈਟਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਨ ਲਈ ਇੱਕ ਬੰਦ ਕਰਨਾ। ਅੰਤ ਵਿੱਚ, ਅਸੀਂ \'ਇਕੱਠਾ ਕਰੋ\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂUTF-8 ਇੰਕੋਡਿੰਗ ਨਾਲ \'Vec <u8>\' ਨੂੰ ਵਾਪਸ \'NAME _ 1\' ਵਿੱਚ ਬਦਲਣ ਲਈ ਬਾਈਟਾਂ ਨੂੰ \'Vec <u8>\' ਅਤੇ \'NAME _ 1:: ਤੋਂ\' ਵਿੱਚ ਫਿਲਟਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।ਇੱਥੇ \'ਨਾਮ _ 1:: ਤੋਂ _ ਯੂਟਫ8 _ ਲੌਸੀ\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਗਈ ਹੈ ਕਿਉਂਕਿ ਗੈਰ-ਏਐੱਸਸੀਆਈਆਈ ਦੇ ਨੁਕਸਾਨਦੇਹ ਪਰਿਵਰਤਨ ਦੇ ਕਾਰਨ ਨਤੀਜਾ ਨਾਮ _ 1 ਪੂਰੀ ਤਰ੍ਹਾਂ ਸਹੀ ਨਹੀਂ ਹੋ ਸਕਦਾ ਹੈ।ਅੱਖਰ। ਜੇ ਤੁਹਾਨੂੰ ਖਾਸ ਯੂਨੀਕੋਡ ਕੋਡ ਬਿੰਦੂਆਂ ਵਾਲੇ ਅੱਖਰਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਵਧੇਰੇ ਗੁੰਝਲਦਾਰ ਪਹੁੰਚ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ, ਜਿਵੇਂ ਕਿ ਯੂਨੀਕੋਡ ਦੀ ਵਰਤੋਂ ਕਰਨਾ।ਸਕੇਲਰ ਮੁੱਲ ਸਾਰਣੀ ਇਹ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਕਿ ਕੀ ਹਰੇਕ ਬਾਈਟ ਦਾ ਇੱਕ ਵੈਧ ਯੂਨੀਕੋਡ ਕੋਡ ਬਿੰਦੂ ਹੈ। \',\' ਚਲੋ ਕਰੰਟ _ ਵਰਡ = word.replace (|c: ਚਾਰ। c.is_ascii (),"). as _ str (); \\n। \\n। ਇਸ ਕਥਨ ਦੇ ਅੰਤ ਵਿੱਚ ਅਸਥਾਈ ਮੁੱਲ ਨੂੰ ਮੁਕਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।ਮੁੱਲ ਜੋ ਅਜੇ ਵੀ ਵਰਤੋਂ ਵਿੱਚ ਹੋਣ ਸਮੇਂ ਮੁਕਤ ਹੈ \'] ', 'ਜੰਗਾਲ ਫਿਲਟਰ ਯੂ. ਟੀ. ਐੱਫ-8 ਅੱਖਰ', ' [\'ਜੰਗਾਲ ਫਿਲਟਰ ਯੂ. ਟੀ. ਐੱਫ.-8 ਅੱਖਰ\', \'ਜੰਗਾਲ ਵਿੱਚ, ਤੁਸੀਂ ਬੰਦ ਕਰਨ ਦੇ ਨਾਲ-ਨਾਲ\' ਸਟਰ \'ਕਿਸਮ ਤੋਂ\' ਆਈਟਰ ਬਾਈਟਸ \'ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਯੂ. ਟੀ. ਐੱਫ.-8 ਅੱਖਰਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰ ਸਕਦੇ ਹੋ।ਜੋ ਬਾਈਟਾਂ ਨੂੰ ਉਹਨਾਂ ਦੇ ਯੂਨੀਕੋਡ ਕੋਡ ਬਿੰਦੂਆਂ ਦੇ ਅਧਾਰ ਉੱਤੇ ਫਿਲਟਰ ਕਰਦਾ ਹੈ। ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n "\'rust\\nfn main () {\\n Let s =" ¥ ". ਤੋਂ _ NAME _ 1 (); \\n\\n// ਨੂੰ ਬਦਲੋਯੂ. ਟੀ. ਐੱਫ.-8 ਇੰਕੋਡਿੰਗ ਨਾਲ ਬਾਈਟਾਂ ਨੂੰ ਨਾਮ _ 1 ਦਿਉ ਬਾਈਟ = s.as_bytes (). iter _ bytes (). ਕਲੋਨਡ (); \\n\\n// ਯੂਨੀਕੋਡ ਕੋਡ ਬਿੰਦੂਆਂ ਨਾਲ ਬਾਈਟਾਂ ਨੂੰ ਬਾਹਰ ਕੱਢੋASCII ਰੇਂਜ (0-127) \\n ਫਿਲਟਰ ਕੀਤੇ ਬਾਈਟਾਂ ਨੂੰ ਛੱਡੋਃ Vec <u8> = bytes.filter (|b। b> = 0x00 & & b <= 0x7f). ਇਕੱਠਾ ਕਰੋ (); \\n\\n// ਫਿਲਟਰ ਕੀਤੇ ਬਾਈਟਾਂ ਨੂੰ ਵਾਪਸ ਇੱਕ ਵਿੱਚ ਬਦਲੋਨਾਮ _ 1 ਨਾਲ ਯੂ. ਟੀ. ਐੱਫ.-8 ਇੰਕੋਡਿੰਗ \\ਨ ਪ੍ਰਿੰਟਲਨ! ("{}", ਨਾਮ _ 1:: ਤੋਂ _ ਯੂ. ਟੀ. ਐੱਫ. 8 _ ਲੌਸੀ (ਫਿਲਟਰਡ _ ਬਾਈਟਸ));// ਪ੍ਰਿੰਟਸ "¥" \\ਨ "\\ਨ" ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, ਅਸੀਂ ਪਹਿਲਾਂ ਨੂੰ ਬਦਲਦੇ ਹਾਂ\'to _ NAME _ 1\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ UTF-8 ਇੰਕੋਡਿੰਗ ਦੇ ਨਾਲ ਇੱਕ \'NAME _ 1\' ਲਈ ਨਾਮ _ 1 \'"¥"। ਫਿਰ ਅਸੀਂ\' ਦੇ ਬਾਈਟਾਂ ਉੱਤੇ ਇੱਕ ਇਟਰੇਟਰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ \'as _ bytes\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ।ਨਾਮ _ 1 ਨੂੰ UTF-8 ਇੰਕੋਡਿੰਗ ਨਾਲ। \\n\\n ਅਸੀਂ \'iter _ bytes\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ ਤਾਂ ਜੋ \'u8\' ਮੁੱਲਾਂ ਉੱਤੇ ਇਟਰੈਟਰ ਨੂੰ ਇੱਕ ਇਟਰੈਟਰ ਵਿੱਚ ਬਦਲਿਆ ਜਾ ਸਕੇ, ਜਿਸ ਦੀ ਵਰਤੋਂ ਅਸੀਂ ਫਿਰ ਨਾਲ ਕਰ ਸਕਦੇ ਹਾਂ।ASCII ਸੀਮਾ (0-127) ਤੋਂ ਬਾਹਰ ਯੂਨੀਕੋਡ ਕੋਡ ਬਿੰਦੂਆਂ ਵਾਲੇ ਬਾਈਟਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਨ ਲਈ ਇੱਕ ਬੰਦ ਕਰਨਾ। ਅੰਤ ਵਿੱਚ, ਅਸੀਂ \'ਇਕੱਠਾ ਕਰੋ\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂUTF-8 ਇੰਕੋਡਿੰਗ ਨਾਲ \'Vec <u8>\' ਨੂੰ ਵਾਪਸ \'NAME _ 1\' ਵਿੱਚ ਬਦਲਣ ਲਈ ਬਾਈਟਾਂ ਨੂੰ \'Vec <u8>\' ਅਤੇ \'NAME _ 1:: ਤੋਂ\' ਵਿੱਚ ਫਿਲਟਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।ਇੱਥੇ \'ਨਾਮ _ 1:: ਤੋਂ _ ਯੂਟਫ8 _ ਲੌਸੀ\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਗਈ ਹੈ ਕਿਉਂਕਿ ਗੈਰ-ਏਐੱਸਸੀਆਈਆਈ ਦੇ ਨੁਕਸਾਨਦੇਹ ਪਰਿਵਰਤਨ ਦੇ ਕਾਰਨ ਨਤੀਜਾ ਨਾਮ _ 1 ਪੂਰੀ ਤਰ੍ਹਾਂ ਸਹੀ ਨਹੀਂ ਹੋ ਸਕਦਾ ਹੈ।ਅੱਖਰ। ਜੇ ਤੁਹਾਨੂੰ ਖਾਸ ਯੂਨੀਕੋਡ ਕੋਡ ਬਿੰਦੂਆਂ ਵਾਲੇ ਅੱਖਰਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਵਧੇਰੇ ਗੁੰਝਲਦਾਰ ਪਹੁੰਚ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ, ਜਿਵੇਂ ਕਿ ਯੂਨੀਕੋਡ ਦੀ ਵਰਤੋਂ ਕਰਨਾ।ਸਕੇਲਰ ਮੁੱਲ ਸਾਰਣੀ ਇਹ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਕਿ ਕੀ ਹਰੇਕ ਬਾਈਟ ਦਾ ਇੱਕ ਵੈਧ ਯੂਨੀਕੋਡ ਕੋਡ ਬਿੰਦੂ ਹੈ। \',\' ਚਲੋ ਕਰੰਟ _ ਵਰਡ = word.replace (|c: ਚਾਰ। c.is_ascii (),"). as _ str (); \\n। \\n। ਇਸ ਕਥਨ ਦੇ ਅੰਤ ਵਿੱਚ ਅਸਥਾਈ ਮੁੱਲ ਨੂੰ ਮੁਕਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।ਮੁੱਲ ਜੋ ਅਜੇ ਵੀ ਵਰਤੋਂ ਵਿੱਚ ਹੁੰਦੇ ਹੋਏ ਮੁਕਤ ਹੈ \',\' ਗਲਤੀ ਸੁਨੇਹਾ ਜੋ ਤੁਸੀਂ ਵੇਖ ਰਹੇ ਹੋ ਉਹ ਇਸ ਲਈ ਹੈ ਕਿਉਂਕਿ \'ਬਦਲੋ\' ਵਿਧੀ ਨਾਲ ਇੱਕ ਨਵਾਂ \'ਨਾਮ _ 1\' ਵਾਪਸ ਆ ਰਿਹਾ ਹੈਸੰਸ਼ੋਧਿਤ ਅੱਖਰ, ਪਰ ਤੁਸੀਂ ਅਸਲ \'NAME _ 1\' ਮੁੱਲ ਉੱਤੇ \'as _ str\' ਢੰਗ ਨੂੰ ਲੈਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਰਹੇ ਹੋ। ਇਹ ਇੱਕ ਅਸਥਾਈ ਮੁੱਲ ਬਣਾਉਂਦਾ ਹੈ ਜੋ \'ਤੇ ਮੁਕਤ ਹੁੰਦਾ ਹੈ।ਬਿਆਨ ਦਾ ਅੰਤ, ਜੋ ਦਹਿਸ਼ਤ ਦਾ ਕਾਰਨ ਬਣ ਸਕਦਾ ਹੈ। \\n\\n ਇਸ ਨੂੰ ਠੀਕ ਕਰਨ ਲਈ, ਤੁਸੀਂ ਸੋਧੇ ਹੋਏ ਨਾਲ ਇੱਕ ਨਵਾਂ \'ਨਾਮ _ 1\' ਬਣਾਉਣ ਲਈ \'ਬਦਲੋ\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ।ਅੱਖਰ, ਅਤੇ ਫਿਰ ਉਸ ਉੱਤੇ \'as _ str\' ਵਿਧੀ ਲਓਃ \\n \'\' rust\\nlet ਕਰੰਟ _ ਵਰਡ = word.replace (|c: ਚਾਰ। c.is_ascii (),"). as _ str (); \\n \'\\n ਵਿਕਲਪਿਕ ਤੌਰ ਉੱਤੇ, ਤੁਸੀਂ ਸੋਧੇ ਹੋਏ ਅੱਖਰਾਂ ਨਾਲ ਇੱਕ ਨਵਾਂ\' ਨਾਮ _ 1 \'ਬਣਾਉਣ ਲਈ\' ਨਕਸ਼ਾ \'ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ, ਅਤੇ ਫਿਰ\' as _ str \'ਲੈ ਸਕਦੇ ਹੋ।ਉਸ ਉੱਤੇ ਵਿਧੀਃ \\n "\'rust\\nlet ਕਰੰਟ _ ਵਰਡ = word.map (|c: ਚਰ। ਜੇਕਰ! c.is_ascii () {c.to_NAME_1 ()}). as _ str (); \\n"\' \\n ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਦੋਵੇਂ ਹੱਲ ਹਨ।ਸੋਧੇ ਹੋਏ ਅੱਖਰਾਂ ਨਾਲ ਇੱਕ ਨਵਾਂ \'ਨਾਮ _ 1\' ਬਣਾਓ, ਜੋ ਬੇਲੋਡ਼ੀ ਮੈਮਰੀ ਅਲਾਟਮੈਂਟ ਦਾ ਕਾਰਨ ਬਣ ਸਕਦਾ ਹੈ ਜੇਕਰ ਅਸਲ \'ਨਾਮ _ 1\' ਪਹਿਲਾਂ ਹੀ ਇਸ ਵਿੱਚ ਅਲਾਟ ਕੀਤਾ ਗਿਆ ਹੈ।ਮੈਮਰੀ। ਜੇ ਤੁਹਾਨੂੰ ਅਸਲ \'ਨਾਮ _ 1\' ਨੂੰ ਸੋਧਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ, ਤਾਂ ਤੁਸੀਂ \'ਨਾਮ _ 1\' ਵਿੱਚ ਨਵੇਂ ਅੱਖਰ ਜੋਡ਼ਨ ਅਤੇ ਹਟਾਉਣ ਲਈ \'ਪੁਸ਼\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ।ਜਿਵੇਂ ਕਿ ਲੋਡ਼ ਹੋਵੇ, ਅੱਖਰ। ਉਦਾਹਰਨ ਲਈਃ \\n \'\' rust\\nlet mut ਕਰੰਟ _ ਵਰਡ = word.to_NAME_1 ();\\ncurrent_word.truncate (current_word.len ()-1);// ਆਖਰੀ ਅੱਖਰ ਹਟਾਓ।ਅੱਖਰ\\ncurrent_word.push (\\\'\\\');// ਸਪੇਸ ਸ਼ਾਮਲ ਕਰੋ\\ncurrent_word.push _ ਸਟਰ (c);// ਸੋਧਿਆ ਹੋਇਆ ਅੱਖਰ ਸ਼ਾਮਲ ਕਰੋ \\n \'\\n ਇਹ ਪਹੁੰਚ ਮੂਲ ਨੂੰ ਸੋਧਦੀ ਹੈ।\'ਨਾਮ _ 1\' ਜਗ੍ਹਾ ਵਿੱਚ ਹੈ, ਇਸ ਲਈ ਤੁਹਾਨੂੰ ਸੋਧੇ ਹੋਏ ਅੱਖਰਾਂ ਨਾਲ ਇੱਕ ਨਵਾਂ \'ਨਾਮ _ 1\' ਬਣਾਉਣ ਦੀ ਜ਼ਰੂਰਤ ਨਹੀਂ ਹੈ। ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਪਹੁੰਚ ਇੱਕ ਨਵਾਂ ਬਣਾਉਣ ਨਾਲੋਂ ਹੌਲੀ ਹੋ ਸਕਦੀ ਹੈ।\'ਨਾਮ _ 1\' ਸੋਧੇ ਹੋਏ ਅੱਖਰਾਂ ਦੇ ਨਾਲ, ਖ਼ਾਸਕਰ ਜੇ \'ਨਾਮ _ 1\' ਬਹੁਤ ਵੱਡਾ ਹੈ। \',\' ਜੰਗਾਲ ਹਟਾਓ ਯੂ. ਟੀ. ਐੱਫ-8 ਅੱਖਰ \'] ', 'ਜੰਗਾਲ ਫਿਲਟਰ ਯੂ. ਟੀ. ਐੱਫ-8 ਅੱਖਰ', ' [\'ਜੰਗਾਲ ਫਿਲਟਰ ਯੂ. ਟੀ. ਐੱਫ.-8 ਅੱਖਰ\', \'ਜੰਗਾਲ ਵਿੱਚ, ਤੁਸੀਂ ਬੰਦ ਕਰਨ ਦੇ ਨਾਲ-ਨਾਲ\' ਸਟਰ \'ਕਿਸਮ ਤੋਂ\' ਆਈਟਰ ਬਾਈਟਸ \'ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਯੂ. ਟੀ. ਐੱਫ.-8 ਅੱਖਰਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰ ਸਕਦੇ ਹੋ।ਜੋ ਬਾਈਟਾਂ ਨੂੰ ਉਹਨਾਂ ਦੇ ਯੂਨੀਕੋਡ ਕੋਡ ਬਿੰਦੂਆਂ ਦੇ ਅਧਾਰ ਉੱਤੇ ਫਿਲਟਰ ਕਰਦਾ ਹੈ। ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n "\'rust\\nfn main () {\\n Let s =" ¥ ". ਤੋਂ _ NAME _ 1 (); \\n\\n// ਨੂੰ ਬਦਲੋਯੂ. ਟੀ. ਐੱਫ.-8 ਇੰਕੋਡਿੰਗ ਨਾਲ ਬਾਈਟਾਂ ਨੂੰ ਨਾਮ _ 1 ਦਿਉ ਬਾਈਟ = s.as_bytes (). iter _ bytes (). ਕਲੋਨਡ (); \\n\\n// ਯੂਨੀਕੋਡ ਕੋਡ ਬਿੰਦੂਆਂ ਨਾਲ ਬਾਈਟਾਂ ਨੂੰ ਬਾਹਰ ਕੱਢੋASCII ਰੇਂਜ (0-127) \\n ਫਿਲਟਰ ਕੀਤੇ ਬਾਈਟਾਂ ਨੂੰ ਛੱਡੋਃ Vec <u8> = bytes.filter (|b। b> = 0x00 & & b <= 0x7f). ਇਕੱਠਾ ਕਰੋ (); \\n\\n// ਫਿਲਟਰ ਕੀਤੇ ਬਾਈਟਾਂ ਨੂੰ ਵਾਪਸ ਇੱਕ ਵਿੱਚ ਬਦਲੋਨਾਮ _ 1 ਨਾਲ ਯੂ. ਟੀ. ਐੱਫ.-8 ਇੰਕੋਡਿੰਗ \\ਨ ਪ੍ਰਿੰਟਲਨ! ("{}", ਨਾਮ _ 1:: ਤੋਂ _ ਯੂ. ਟੀ. ਐੱਫ. 8 _ ਲੌਸੀ (ਫਿਲਟਰਡ _ ਬਾਈਟਸ));// ਪ੍ਰਿੰਟਸ "¥" \\ਨ "\\ਨ" ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, ਅਸੀਂ ਪਹਿਲਾਂ ਨੂੰ ਬਦਲਦੇ ਹਾਂ\'to _ NAME _ 1\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ UTF-8 ਇੰਕੋਡਿੰਗ ਦੇ ਨਾਲ ਇੱਕ \'NAME _ 1\' ਲਈ ਨਾਮ _ 1 \'"¥"। ਫਿਰ ਅਸੀਂ\' ਦੇ ਬਾਈਟਾਂ ਉੱਤੇ ਇੱਕ ਇਟਰੇਟਰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ \'as _ bytes\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ।ਨਾਮ _ 1 ਨੂੰ UTF-8 ਇੰਕੋਡਿੰਗ ਨਾਲ। \\n\\n ਅਸੀਂ \'iter _ bytes\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ ਤਾਂ ਜੋ \'u8\' ਮੁੱਲਾਂ ਉੱਤੇ ਇਟਰੈਟਰ ਨੂੰ ਇੱਕ ਇਟਰੈਟਰ ਵਿੱਚ ਬਦਲਿਆ ਜਾ ਸਕੇ, ਜਿਸ ਦੀ ਵਰਤੋਂ ਅਸੀਂ ਫਿਰ ਨਾਲ ਕਰ ਸਕਦੇ ਹਾਂ।ASCII ਸੀਮਾ (0-127) ਤੋਂ ਬਾਹਰ ਯੂਨੀਕੋਡ ਕੋਡ ਬਿੰਦੂਆਂ ਵਾਲੇ ਬਾਈਟਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਨ ਲਈ ਇੱਕ ਬੰਦ ਕਰਨਾ। ਅੰਤ ਵਿੱਚ, ਅਸੀਂ \'ਇਕੱਠਾ ਕਰੋ\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂUTF-8 ਇੰਕੋਡਿੰਗ ਨਾਲ \'Vec <u8>\' ਨੂੰ ਵਾਪਸ \'NAME _ 1\' ਵਿੱਚ ਬਦਲਣ ਲਈ ਬਾਈਟਾਂ ਨੂੰ \'Vec <u8>\' ਅਤੇ \'NAME _ 1:: ਤੋਂ\' ਵਿੱਚ ਫਿਲਟਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।ਇੱਥੇ \'ਨਾਮ _ 1:: ਤੋਂ _ ਯੂਟਫ8 _ ਲੌਸੀ\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਗਈ ਹੈ ਕਿਉਂਕਿ ਗੈਰ-ਏਐੱਸਸੀਆਈਆਈ ਦੇ ਨੁਕਸਾਨਦੇਹ ਪਰਿਵਰਤਨ ਦੇ ਕਾਰਨ ਨਤੀਜਾ ਨਾਮ _ 1 ਪੂਰੀ ਤਰ੍ਹਾਂ ਸਹੀ ਨਹੀਂ ਹੋ ਸਕਦਾ ਹੈ।ਅੱਖਰ। ਜੇ ਤੁਹਾਨੂੰ ਖਾਸ ਯੂਨੀਕੋਡ ਕੋਡ ਬਿੰਦੂਆਂ ਵਾਲੇ ਅੱਖਰਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਵਧੇਰੇ ਗੁੰਝਲਦਾਰ ਪਹੁੰਚ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ, ਜਿਵੇਂ ਕਿ ਯੂਨੀਕੋਡ ਦੀ ਵਰਤੋਂ ਕਰਨਾ।ਸਕੇਲਰ ਮੁੱਲ ਸਾਰਣੀ ਇਹ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਕਿ ਕੀ ਹਰੇਕ ਬਾਈਟ ਦਾ ਇੱਕ ਵੈਧ ਯੂਨੀਕੋਡ ਕੋਡ ਬਿੰਦੂ ਹੈ। \',\' ਚਲੋ ਕਰੰਟ _ ਵਰਡ = word.replace (|c: ਚਾਰ। c.is_ascii (),"). as _ str (); \\n। \\n। ਇਸ ਕਥਨ ਦੇ ਅੰਤ ਵਿੱਚ ਅਸਥਾਈ ਮੁੱਲ ਨੂੰ ਮੁਕਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।ਮੁੱਲ ਜੋ ਅਜੇ ਵੀ ਵਰਤੋਂ ਵਿੱਚ ਹੁੰਦੇ ਹੋਏ ਮੁਕਤ ਹੈ \',\' ਗਲਤੀ ਸੁਨੇਹਾ ਜੋ ਤੁਸੀਂ ਵੇਖ ਰਹੇ ਹੋ ਉਹ ਇਸ ਲਈ ਹੈ ਕਿਉਂਕਿ \'ਬਦਲੋ\' ਵਿਧੀ ਨਾਲ ਇੱਕ ਨਵਾਂ \'ਨਾਮ _ 1\' ਵਾਪਸ ਆ ਰਿਹਾ ਹੈਸੰਸ਼ੋਧਿਤ ਅੱਖਰ, ਪਰ ਤੁਸੀਂ ਅਸਲ \'NAME _ 1\' ਮੁੱਲ ਉੱਤੇ \'as _ str\' ਢੰਗ ਨੂੰ ਲੈਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਰਹੇ ਹੋ। ਇਹ ਇੱਕ ਅਸਥਾਈ ਮੁੱਲ ਬਣਾਉਂਦਾ ਹੈ ਜੋ \'ਤੇ ਮੁਕਤ ਹੁੰਦਾ ਹੈ।ਬਿਆਨ ਦਾ ਅੰਤ, ਜੋ ਦਹਿਸ਼ਤ ਦਾ ਕਾਰਨ ਬਣ ਸਕਦਾ ਹੈ। \\n\\n ਇਸ ਨੂੰ ਠੀਕ ਕਰਨ ਲਈ, ਤੁਸੀਂ ਸੋਧੇ ਹੋਏ ਨਾਲ ਇੱਕ ਨਵਾਂ \'ਨਾਮ _ 1\' ਬਣਾਉਣ ਲਈ \'ਬਦਲੋ\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ।ਅੱਖਰ, ਅਤੇ ਫਿਰ ਉਸ ਉੱਤੇ \'as _ str\' ਵਿਧੀ ਲਓਃ \\n \'\' rust\\nlet ਕਰੰਟ _ ਵਰਡ = word.replace (|c: ਚਾਰ। c.is_ascii (),"). as _ str (); \\n \'\\n ਵਿਕਲਪਿਕ ਤੌਰ ਉੱਤੇ, ਤੁਸੀਂ ਸੋਧੇ ਹੋਏ ਅੱਖਰਾਂ ਨਾਲ ਇੱਕ ਨਵਾਂ\' ਨਾਮ _ 1 \'ਬਣਾਉਣ ਲਈ\' ਨਕਸ਼ਾ \'ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ, ਅਤੇ ਫਿਰ\' as _ str \'ਲੈ ਸਕਦੇ ਹੋ।ਉਸ ਉੱਤੇ ਵਿਧੀਃ \\n "\'rust\\nlet ਕਰੰਟ _ ਵਰਡ = word.map (|c: ਚਰ। ਜੇਕਰ! c.is_ascii () {c.to_NAME_1 ()}). as _ str (); \\n"\' \\n ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਦੋਵੇਂ ਹੱਲ ਹਨ।ਸੋਧੇ ਹੋਏ ਅੱਖਰਾਂ ਨਾਲ ਇੱਕ ਨਵਾਂ \'ਨਾਮ _ 1\' ਬਣਾਓ, ਜੋ ਬੇਲੋਡ਼ੀ ਮੈਮਰੀ ਅਲਾਟਮੈਂਟ ਦਾ ਕਾਰਨ ਬਣ ਸਕਦਾ ਹੈ ਜੇਕਰ ਅਸਲ \'ਨਾਮ _ 1\' ਪਹਿਲਾਂ ਹੀ ਇਸ ਵਿੱਚ ਅਲਾਟ ਕੀਤਾ ਗਿਆ ਹੈ।ਮੈਮਰੀ। ਜੇ ਤੁਹਾਨੂੰ ਅਸਲ \'ਨਾਮ _ 1\' ਨੂੰ ਸੋਧਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ, ਤਾਂ ਤੁਸੀਂ \'ਨਾਮ _ 1\' ਵਿੱਚ ਨਵੇਂ ਅੱਖਰ ਜੋਡ਼ਨ ਅਤੇ ਹਟਾਉਣ ਲਈ \'ਪੁਸ਼\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ।ਜਿਵੇਂ ਕਿ ਲੋਡ਼ ਹੋਵੇ, ਅੱਖਰ। ਉਦਾਹਰਨ ਲਈਃ \\n \'\' rust\\nlet mut ਕਰੰਟ _ ਵਰਡ = word.to_NAME_1 ();\\ncurrent_word.truncate (current_word.len ()-1);// ਆਖਰੀ ਅੱਖਰ ਹਟਾਓ।ਅੱਖਰ\\ncurrent_word.push (\\\'\\\');// ਸਪੇਸ ਸ਼ਾਮਲ ਕਰੋ\\ncurrent_word.push _ ਸਟਰ (c);// ਸੋਧਿਆ ਹੋਇਆ ਅੱਖਰ ਸ਼ਾਮਲ ਕਰੋ \\n \'\\n ਇਹ ਪਹੁੰਚ ਮੂਲ ਨੂੰ ਸੋਧਦੀ ਹੈ।\'ਨਾਮ _ 1\' ਜਗ੍ਹਾ ਵਿੱਚ ਹੈ, ਇਸ ਲਈ ਤੁਹਾਨੂੰ ਸੋਧੇ ਹੋਏ ਅੱਖਰਾਂ ਨਾਲ ਇੱਕ ਨਵਾਂ \'ਨਾਮ _ 1\' ਬਣਾਉਣ ਦੀ ਜ਼ਰੂਰਤ ਨਹੀਂ ਹੈ। ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਪਹੁੰਚ ਇੱਕ ਨਵਾਂ ਬਣਾਉਣ ਨਾਲੋਂ ਹੌਲੀ ਹੋ ਸਕਦੀ ਹੈ।\'ਨਾਮ _ 1\' ਸੋਧੇ ਹੋਏ ਅੱਖਰਾਂ ਨਾਲ, ਖਾਸ ਕਰਕੇ ਜੇ \'ਨਾਮ _ 1\' ਬਹੁਤ ਵੱਡਾ ਹੈ. \',\' ਜੰਗਾਲ ਹਟਾਓ ਯੂ. ਟੀ. ਐੱਫ-8 ਅੱਖਰ \',\' ਜੰਗਾਲ ਵਿੱਚ, ਤੁਸੀਂ ਯੂ. ਟੀ. ਐੱਫ-8 ਨੂੰ ਹਟਾ ਸਕਦੇ ਹੋ।\'ਨਾਮ _ 1\' ਕਿਸਮ ਤੋਂ \'ਬਦਲੋ\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਨ ਵਾਲੇ ਅੱਖਰ, ਇੱਕ ਬੰਦ ਹੋਣ ਦੇ ਨਾਲ ਜੋ ਉਹਨਾਂ ਦੇ ਯੂਨੀਕੋਡ ਕੋਡ ਬਿੰਦੂਆਂ ਦੇ ਅਧਾਰ ਤੇ ਅੱਖਰਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਦੇ ਹਨ।ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਨ ਹੈਃ \\n "\'rust\\nfn main () {\\n ਮੰਨ ਲਓ s =" ¥ ". ਤੋਂ _ NAME _ 1 (); \\n\\n// ASCII ਸੀਮਾ ਤੋਂ ਬਾਹਰ ਯੂਨੀਕੋਡ ਕੋਡ ਬਿੰਦੂਆਂ ਵਾਲੇ ਸਾਰੇ ਅੱਖਰ ਹਟਾਓ।(0-127) \\n ਫਿਲਟਰਡ _ s = s.replace (|c: ਚਾਰ। c.is_ascii (), "); \\n\\n ਪ੍ਰਿੰਟਲਨ! (" {} ", ਫਿਲਟਰਡ _ s);// ਪ੍ਰਿੰਟਸ" \\n} \\n "ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, ਅਸੀਂ ਪਹਿਲਾਂ\'to _ NAME _ 1\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ UTF-8 ਇੰਕੋਡਿੰਗ ਨਾਲ \'NAME _ 1\' ਨੂੰ \'NAME _ 1\' ਵਿੱਚ ਬਦਲੋ। ਫਿਰ ਅਸੀਂ ਸਾਰੇ ਅੱਖਰਾਂ ਨੂੰ ਹਟਾਉਣ ਲਈ \'ਬਦਲੋ\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ।ASCII ਸੀਮਾ (0-127) ਤੋਂ ਬਾਹਰ ਯੂਨੀਕੋਡ ਕੋਡ ਬਿੰਦੂਆਂ ਨਾਲ। ਬੰਦ \'|c: ਚਾਰ।! c.is_ascii ()\' ਉਹਨਾਂ ਦੇ ਯੂਨੀਕੋਡ ਕੋਡ ਦੇ ਅਧਾਰ ਉੱਤੇ ਅੱਖਰਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਦਾ ਹੈ।ਬਿੰਦੂ ਦਿੰਦਾ ਹੈ, ਅਤੇ ਗ਼ੈਰ-ਏ. ਐੱਸ. ਸੀ. ਆਈ. ਆਈ. ਕੋਡ ਬਿੰਦੂਆਂ ਵਾਲੇ ਅੱਖਰਾਂ ਲਈ ਇੱਕ ਖਾਲੀ ਨਾਮ ਵਾਪਸ ਕਰਦਾ ਹੈ। \\n\\n ਨੋਟ ਕਰੋ ਕਿ ਰਸਟ ਵਿੱਚ \'ਨਾਮ _ 1\' ਕਿਸਮ ਪਰਿਵਰਤਨਯੋਗ ਹੈ, ਇਸ ਲਈ ਜਦੋਂ ਤੁਸੀਂ ਸੋਧ ਕਰਦੇ ਹੋ\'ਨਾਮ _ 1\' ਅੱਖਰਾਂ ਨੂੰ ਹਟਾ ਕੇ, ਤੁਸੀਂ ਲੋਡ਼ ਪੈਣ \'ਤੇ ਸੋਧੇ ਹੋਏ ਅੱਖਰਾਂ ਨਾਲ ਇੱਕ ਨਵਾਂ\' ਨਾਮ _ 1 \'ਬਣਾ ਸਕਦੇ ਹੋ। ਵਿਕਲਪਿਕ ਤੌਰ\' ਤੇ, ਤੁਸੀਂ \'ਨਕਸ਼ਾ\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ।ਸੋਧੇ ਹੋਏ ਅੱਖਰਾਂ ਨਾਲ ਇੱਕ ਨਵਾਂ \'ਨਾਮ _ 1\' ਬਣਾਉਣ ਲਈਃ \\n "\'rust\\nlet ਫਿਲਟਰਡ _ s = s.map (|c: ਚਰ। ਜੇਕਰ! c.is_ascii () {" "}); \\n"\' \\n ਇਹ ਪਹੁੰਚਸੋਧੇ ਹੋਏ ਅੱਖਰਾਂ ਨਾਲ ਇੱਕ ਨਵਾਂ \'ਨਾਮ _ 1\' ਬਣਾਉਂਦਾ ਹੈ, ਇਸ ਲਈ ਇਹ ਅਸਲ \'ਨਾਮ _ 1\' ਨੂੰ ਸੋਧਣ ਨਾਲੋਂ ਤੇਜ਼ ਹੋ ਸਕਦਾ ਹੈ, ਖ਼ਾਸਕਰ ਜੇ \'ਨਾਮ _ 1\' ਹੈਬਹੁਤ ਵੱਡਾ। ਹਾਲਾਂਕਿ, ਇਹ ਇੱਕ ਨਵਾਂ \'ਨਾਮ _ 1\' ਵੀ ਬਣਾਉਂਦਾ ਹੈ ਜੋ ਵਾਧੂ ਮੈਮਰੀ ਲੈਂਦਾ ਹੈ, ਇਸ ਲਈ ਇਹ ਅਸਲ \'ਨਾਮ _ 1\' ਨੂੰ ਸੋਧਣ ਨਾਲੋਂ ਹੌਲੀ ਹੋ ਸਕਦਾ ਹੈ।ਜੇਕਰ \'NAME _ 1\' ਛੋਟਾ ਹੈ ਅਤੇ ਮੈਮਰੀ ਵਿੱਚ ਫਿੱਟ ਹੁੰਦਾ ਹੈ। \',\' ਚਲੋ ਕਰੰਟ _ ਵਰਡ = word.replace (|c: ਚਾਰ। c.is_ascii (), "); \\n।-----------ਬਾਈਡਿੰਗ \'ਕਰੰਟ _ ਵਰਡ\'ਇੱਥੇ ਘੋਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਹੈ \\n... \\n87। ਜੇਕਰ temp_chunk.length + temp_chunk.gaps + & current_word.len () <= ਮੈਕਸ _ ਚੰਕ _ ਲੰਬਾਈ {\\n।---------------------ਬਾਅਦ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈਇੱਥੇ \\n88। temp_chunk.set_word (& ਕਰੰਟ _ ਵਰਡ); \\n। ', 'ਜੰਗਾਲ ਫਿਲਟਰ ਯੂ. ਟੀ. ਐੱਫ-8 ਅੱਖਰ \n ']