Back to Question Center
0

ਰੂਬੀ CSV ਲਾਇਬ੍ਰੇਰੀ, ਭਾਗ II ਦੀ ਇੱਕ ਗਾਈਡ            ਰੂਬੀ ਲਈ ਇੱਕ ਗਾਈਡ CSV ਲਾਇਬ੍ਰੇਰੀ, ਭਾਗ Iirelated ਵਿਸ਼ੇ: ਵਧੀਆ ਪ੍ਰੈਕਟਿਸਸ ਨਿਊਜ਼ ਐਂਡ & ਓਪੀਨੀਅਨਰੀਬੀ ਸੈਮੈਲ

1 answers:
ਰੂਬੀ ਲਈ ਇੱਕ ਗਾਈਡ CSV ਲਾਇਬ੍ਰੇਰੀ, ਭਾਗ II

ਰੂਬੀ CSV ਲਾਇਬ੍ਰੇਰੀ, ਭਾਗ II ਦੀ ਇੱਕ ਗਾਈਡਰੂਬੀ ਲਈ ਇੱਕ ਗਾਈਡ CSV ਲਾਇਬ੍ਰੇਰੀ, ਭਾਗ Iirelated ਵਿਸ਼ੇ:
ਵਧੀਆ ਪ੍ਰੈਕਟਿਸਸ ਨਿਊਜ਼ ਅਤੇ ਓਪੀਨੀਅਨ ਰੇਬੀ ਸਮਾਲਟ

ਚੰਗੀ ਨੌਕਰੀ, ਬੇਟੇ! - ਸੇਮਟ ਬੌਬ (ਜੇ ਤੁਸੀਂ ਉਲਝਣ ਵਿਚ ਹੋ ਜੋ ਸੇਮਬਟ ਬੌਬ ਹੈ ਤਾਂ ਤੁਸੀਂ ਇਸ ਟਿਊਟੋਰਿਯਲ ਦੇ ਭਾਗ 1 ਨੂੰ ਪੜਨਾ ਚਾਹ ਸਕਦੇ ਹੋ)

ਅੰਕਲ ਬੌਬ ਸਾਡੇ ਦੁਆਰਾ ਕੀਤੇ ਗਏ ਕੰਮ ਤੋਂ ਖੁਸ਼ ਹੈ. ਪਰ ਇੱਕ ਗੱਲ ਬਾਕੀ ਰਹਿ ਗਈ ਹੈ .ਇਸ ਫਾਇਲ ਨੂੰ ਮਿਟਾਓ?

ਰੂਬੀ CSV ਲਾਇਬ੍ਰੇਰੀ, ਭਾਗ II ਦੀ ਇੱਕ ਗਾਈਡਰੂਬੀ ਲਈ ਇੱਕ ਗਾਈਡ CSV ਲਾਇਬ੍ਰੇਰੀ, ਭਾਗ Iirelated ਵਿਸ਼ੇ:
ਵਧੀਆ ਪ੍ਰੈਕਟਿਸਸ ਨਿਊਜ਼ ਅਤੇ ਓਪੀਨੀਅਨ ਰੇਬੀ ਸਮਾਲਟ

ਨਵੇਂ ਕਰਮਚਾਰੀ ਉਲਝਣ 'ਚ ਹਨ, ਹਰ ਕਾਲਮ ਦਾ ਕੀ ਅਰਥ ਹੈ? 34 ਜਾਂ 2548 ਕੀ ਹੈ? ਜੋ ਸਾਨੂੰ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਉਹ ਹੈ ਸਿਰਲੇਖ ਸਾਡੀ CSV ਫਾਈਲ ਵਿਚ. ਆਓ ਸਾਡੀ ਫਾਈਲ ਨੂੰ ਅਪਡੇਟ ਕਰੀਏ (ਹੇਠਲੇ ਪ੍ਹੈਰੇ ਦੇ ਸਧਾਰਨ ਟੈਕਸਟ ਫਾਰਮੈਟ ਵਿੱਚ ਹੈਡਰ ਸ਼ਾਮਲ ਹਨ):

     ਨਾਮ, ਟਾਈਮਜ਼ ਆ ਗਿਆ, ਕੁਲ ਖਰਚ $ ਖਰਚ, ਫੂਡ ਫੀਡਬੈਕਡੈਨ, 34,2548, ਲਵਿਨ ਇਸ ਨੂੰ!ਮਾਰੀਆ, 55,5054, "ਚੰਗਾ, ਸੁਆਦੀ ਭੋਜਨ"ਕਾਰਲੋਸ, 22,4352, "ਮੈਂ ਹਾਂ" "ਖੁਸ਼ ਹਾਂ", ਪਰ ਬਿਹਤਰ ਹੋ ਸਕਦਾ ਹੈ "ਸਟੈਫਨੀ, 34,6542, ਮੈਂ ਵੱਡੇ ਸਟੈਕਸ ਚਾਹੁੰਦਾ ਹਾਂ !!!!!     

ਹੁਣ, ਆਓ ਤੇ ਸਾਡੀ ਫਾਈਲ ਨੂੰ ਰੂਬੀ ਵਿਚ ਅਯਾਤ ਕਰੋ (ਮੰਨ ਲਓ ਕਿ ਉਸਦਾ ਨਾਂ 'ਮਹਿਮਾਨ. Csv' ਹੈ):

     'ਸੀਐਸਵੀ' ਦੀ ਲੋੜ ਹੈ ਕਿਉਂਕਿ ਸੀਐਸਵੀ ਮਿਆਰੀ ਲਾਇਬਰੇਰੀ ਦਾ ਹਿੱਸਾ ਹੈ, ਸਾਨੂੰ ਇਹ 'ਲੋੜੀਂਦਾ' ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ, ਯਾਦ ਹੈ?ਮਹਿਮਾਨ = CSV ('ਗੈਸਟ - фотограф на свадьбу цены. csv') ਪੜ੍ਹੋ # 'ਪੂਰੀ' ਨੂੰ ਇੱਕ 'ਮਹਿਮਾਨ' ਵੇਰੀਏਬਲ     
ਵਿੱਚ ਪੜ੍ਹੋ

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

     ["ਨਾਮ", "ਟਾਈਮਜ਼ ਐਰੈਬੈੱਡ", "ਕੁੱਲ $ ਖਰਚਿਆ ਗਿਆ", "ਫੂਡ ਫੀਡਬੈਕ"]     

ਆਉ ਹੁਣ CSV ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਦੱਸੀਏ ਕਿ ਬਾਕੀ ਦੇ ਕਿਸੇ ਵੀ ਤਰਾਂ ਦੀ ਪਹਿਲੀ ਕਤਾਰ ਦਾ ਇਲਾਜ ਨਾ ਕਰੀਏ. ਅਸੀਂ ਇਹ ਕਿਵੇਂ ਕਰਦੇ ਹਾਂ? ਯਾਦ ਰੱਖੋ, ਹਰ ਇੱਕ CSV ਵਿਧੀ ਜੋ ਰੂਬੀ ਵਿੱਚ "csv-like" ਕੁਝ ਬਣਾਉਂਦਾ ਹੈ ਚੋਣਾਂ ਦੀ ਸੂਚੀ (ਅਸੀਂ 13) ਕਨਵਰਟਰਾਂ ਨੂੰ ਇਸਤੇਮਾਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ: ਪਹਿਲੇ ਭਾਗ ਵਿੱਚ ਅੰਕੀ ) ਜੋ ਕਿ ਮੂਲ ਤੌਰ ਤੇ ਨਿਰਦੇਸ਼ ਦਿੰਦਾ ਹੈ ਲਾਇਬਰੇਰੀ ਫਾਇਲ (ਜਾਂ ਸਤਰ) ਨੂੰ ਵੱਖਰੇ ਢੰਗ ਨਾਲ ਵਰਤਣ ਦੇ ਤਰੀਕੇ ਨਾਲ ਵਰਤਣ ਦੀ ਬਜਾਏ ਇਸ ਨੂੰ ਡਿਫਾਲਟ ਰੂਪ ਵਿੱਚ ਕਿਵੇਂ ਵਰਤਦਾ ਹੈ ਬਹੁਤ ਸਾਰੇ ਵਿਕਲਪਾਂ ਵਿੱਚੋਂ, ਇੱਕ ਸੀਐਸਵੀ ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਇਹ ਦੱਸਣ ਲਈ ਹੈ ਕਿ ਪਹਿਲੀ ਲਾਈਨ ਇਕ ਸਿਰਲੇਖ ਹੈ, ਜੋ ਹੈ : ਹੈਡਰ => ਸਹੀ . ਆਉ ਇਸ ਵਿਕਲਪ ਨੂੰ ਜੋੜ ਕੇ ਸਾਡੇ 2-ਲਾਈਨ ਦੇ ਕੋਡ ਵਿੱਚ ਸਾਡੀ ਦੂਜੀ ਲਾਈਨ ਨੂੰ ਸੰਸ਼ੋਧਿਤ ਕਰੀਏ:

     ਮਹਿਮਾਨ = CSV. ਪੜ੍ਹੋ ('ਮਹਿਮਾਨ. csv', ਸਿਰਲੇਖ: ਸਹੀ)     

ਤਾਂ, ਤੁਸੀਂ ਸ਼ਾਇਦ ਸੋਚੋ, ਕੀ ਹੁਣ ਵੱਖਰੀ ਹੈ? ਆਉ ਚੱਲੀਏ ਅਤੇ ਵੇਖੀਏ ਕੀ ਮਹਿਮਾਨ ਵੇਰੀਬਲ ਵਿੱਚ ਮੌਜੂਦਾ ਹੈ (ਸੰਕੇਤ: ਇਹ ਹੁਣ ਕੋਈ ਡਬਲ ਐਰੇ ਨਹੀਂ ਹੈ!):

     #        

ਸਿਮਟ ਫਿਕਰ ਬਾਰੇ ਚਿੰਤਾ ਕਰੋ ਕਿ ਇਹ ਸਭ ਹੁਣ ਲਈ ਕੀ ਅਰਥ ਰੱਖਦਾ ਹੈ, ਅਸੀਂ ਇਸਨੂੰ ਹੇਠਾਂ ਕਦਮ-ਦਰ-ਕਦਮ ਦੱਸਾਂਗੇ.

ਹੈਡਰ ਦੇ ਨਾਲ ਫਾਈਲਾਂ ਵਿਸ਼ੇਸ਼ ਹਨ

ਇਕ (ਡਬਲ) ਐਰੇ ਦੀ ਬਜਾਏ, ਸਾਡੇ ਮਹਿਮਾਨ ਵੇਰੀਏਬਲ ਹੁਣ ਇੱਕ ਸੀਐਸਵੀ :: ਸਾਰਣੀ ਕਿਸਮ ਦੀ ਵਸਤੂ ਹੈ. ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਸ਼ਾਇਦ ਜਾਣਦੇ ਹੋਵੋ, ਰੂਬੀ ਵਿਚ ਹਰ ਇਕ ਚੀਜ਼ ਦੇ ਆਪਣੇ ਵੱਖਰੇ ਢੰਗ ਹਨ. ਇਹੀ CSV :: ਸਾਰਣੀ ਲਈ ਸਹੀ ਹੈ.

ਖੁਸ਼ਕਿਸਮਤੀ ਨਾਲ, ਇਹ ਨਵਾਂ ਔਬਜੈਕਟ ਟਾਈਪ ਸਾਡੀ ਡਬਲ ਆਰਐਰਈ ਵਰਗੀ ਹੀ ਕੰਮ ਕਰਦਾ ਹੈ. ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਹਰੇਕ ਲਾਈਨ ਹਰੇਕ ਦੇ ਨਾਲ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਡਬਲ ਐਰੇ ਦੇ ਘੁੰਮ ਸਕਦੇ ਹੋ, ਉਸੇ ਤਰ੍ਹਾਂ ਹੀ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਤੁਸੀਂ ਸੀਐਸਵੀ :: ਸਾਰਣੀ ਲਈ ਇੱਕੋ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ:

     ਮਹਿਮਾਨ ਹਰ ਇੱਕ | guest_row |p guest_row #    

ਤੁਹਾਨੂੰ 4 ਲਾਈਨਾਂ ਨੂੰ ਆਊਟਪੁਟ ਦੇ ਤੌਰ ਤੇ ਦੇਖਣਾ ਚਾਹੀਦਾ ਹੈ (4 ਦੀ ਬਜਾਏ, 4, ਇਹ ਹੁਣ ਪਛਾਣ ਕਰਦਾ ਹੈ ਕਿ ਸਾਡੀ ਪਹਿਲੀ ਲਾਈਨ ਇੱਕ ਅਸਲ ਹੈਡਰ ਹੈ). ਇਨ੍ਹਾਂ ਵਿੱਚੋਂ ਹਰੇਕ ਚੀਜ਼, ਜਿਵੇਂ ਇਸਦਾ ਨਾਮ ਕਹਿੰਦਾ ਹੈ, ਇਕ ਕਤਾਰ ਦਾ ਵੀ ਹਵਾਲਾ ਦੇ ਰਿਹਾ ਹੈ.

ਅਸਲ ਵਿੱਚ, ਜੇ ਅਸੀਂ ਸਿਰਲੇਖਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਦੇ ਹਾਂ: ਸਹੀ ਸਾਨੂੰ ਮਿਲਦਾ ਹੈ:

  • ਸੀਐਸਵੀ :: ਟੇਬਲ ਡਬਲ ਐਰੇ ਦੀ ਬਜਾਏ
  • ਸੀਐਸਵੀ :: ਕਤਾਰ ਉਹ ਵਸਤੂ ਜੋ ਕਿ ਕਤਾਰਾਂ ਨੂੰ ਦਰਸਾਉਂਦੇ ਹਨ.

ਜੇ ਤੁਸੀਂ ਡਬਲ ਐਰੇ ਨੂੰ ਵਾਪਸ ਪ੍ਰਾਪਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਬਸ ਸੀਐਸਵੀ :: ਸਾਰਣੀ # to_a ਵਿਧੀ ਨੂੰ ਕਾਲ ਕਰੋ. ਆਓ ਦੇਖੀਏ ਕੀ ਹੁੰਦਾ ਹੈ:

     ਮਹਿਮਾਨ = CSV. ਪੜ੍ਹੋ ('ਮਹਿਮਾਨ. csv', ਹੈਡਰ: ਸਹੀ) # =>   ਪੀ ਮਹਿਮਾਨ to_a # ਆਉਟਪੁਟ # [["ਨਾਮ", "ਟਾਈਮਜ਼ ਐਰੈ ਆਖਿਆ", "ਕੁੱਲ ਖਰਚਿਆ ਗਿਆ", "ਫੂਡ ਫੀਡਬੈਕ"], ["ਦਾਨ", "34", "2548", "ਲਵਿਨ ਇਟ!"]    .     

ਤੁਸੀਂ ਫਾਇਲ ਦੀ ਸਟ੍ਰਿੰਗ ਨੁਮਾਇੰਦਗੀ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ to_a ਦੀ ਬਜਾਏ #to_s ਦੀ ਵਰਤੋਂ ਵੀ ਕਰ ਸਕਦੇ ਹੋ:

     ਪੀ ਮਹਿਮਾਨ to_s# => "ਨਾਂ, ਟਾਈਮਜ਼ ਪਹੁੰਚਿਆ, ਕੁਲ ਖਰਚ $, ਫੂਡ ਫੀਡਬੈਕ \ n ਡਾਨ, 34,2548, .    

ਵੱਖ ਵੱਖ ਵਸਤੂਆਂ ਕਿਉਂ?

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

     ["ਦਾਨ", "34", "2548", "ਲਵਿਨ ਇਟ!"]     

ਜਦੋਂ ਅਸੀਂ ਸਿਰਲੇਖ ਜੋੜਦੇ ਹਾਂ ਤਾਂ ਚੀਜ਼ਾਂ ਬਦਲਦੀਆਂ ਹਨ: ਸਹੀ ਵਿਕਲਪ:

"2548" "ਫੂਡ ਫੀਡਬੈਕ": "ਲਵਿਨ ਇਸ ਨੂੰ!">
     #   

ਕਲਪਨਾ ਕਰੋ ਕਿ ਤੁਸੀਂ ਮਹਿਮਾਨਾਂ ਦੇ ਪਹਿਲੇ ਕਾਲਮ ਨੂੰ ਛਾਪਣਾ ਚਾਹੁੰਦੇ ਸੀ. csv , ਜਿਸ ਵਿੱਚ ਗਿਸਟ ਨਾਂ ਹਨ. ਜੇ ਡੈਨ ਨੂੰ ਇਕ ਆਮ ਐਰੇ ਵਜੋਂ ਦਰਸਾਇਆ ਗਿਆ ਹੈ, ਤਾਂ ਤੁਹਾਨੂੰ ਉਸ ਡੇਟਾ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਡਾਨ_ਅਰੇ [0] ਨੂੰ ਕਾਲ ਕਰਨਾ ਪਵੇਗਾ. ਸਾਡਾ ਕੋਡ ਇਸ ਤਰਾਂ ਦਾ ਦਿਖਾਈ ਦੇਵੇਗਾ (ਇਸ ਸਮੇਂ ਮੈਂ ਵੇਅਰਚ ਨੂੰ ਇਸ ਦੀ ਬਜਾਏ CSV ਫਾਈਲ ਤੋਂ ਪੜ੍ਹਨ ਲਈ ਪੜ੍ਹਨ ) ਦੀ ਵਰਤੋਂ ਕਰਾਂਗਾ:

     ਮਹਿਮਾਨ = CSV. foreach ('ਮਹਿਮਾਨ. csv') ਕਰੋ | ਕਤਾਰ |ਪਾਉਂਦਾ ਹੈ [0]ਅੰਤ ਵਿੱਚ = = ਆਉਟਪੁੱਟ "ਨਾਂ", "ਦਾਨ", "ਮਾਰੀਆ", "ਕਾਰਲੋਸ", "ਸਟੈਫਨੀ" ਅਲੱਗ ਲਾਈਨਾਂ ਤੇ     

ਜੇ ਕੋਈ ਹੋਰ ਤੁਹਾਡੇ ਕੋਡ ਨੂੰ ਪੜ੍ਹ ਰਿਹਾ ਸੀ, ਤਾਂ ਉਹ ਸ਼ਾਇਦ ਸੋਚੇਗਾ ਕਿ ਕਤਾਰ [0] ਦਾ ਮਤਲਬ ਹੈ ਨਾਲ ਹੀ, ਸਾਡੇ ਕੋਲ 'ਨਾਮ' ਆਉਟਪੁਟ ਵਿੱਚ ਪਹਿਲੀ ਲਾਈਨ ਦੇ ਰੂਪ ਵਿੱਚ ਹੈ, ਜੋ ਕਿ ਨਿਸ਼ਚਿਤ ਨਹੀਂ ਹੈ ਕਿ ਅਸੀਂ ਕੀ ਚਾਹੁੰਦੇ ਹਾਂ. ਅਸੀਂ ਸਿਰਲੇਖਾਂ ਦੇ ਬਿਨਾਂ ਮਹਿਮਾਨਾਂ ਦੇ ਨਾਂ ਛਾਪਣਾ ਚਾਹੁੰਦੇ ਹਾਂ! ਬਿਹਤਰ ਅਜੇ ਤੱਕ, ਲਾਈਨ ਵਿੱਚ ਉਸ ਕਾਲਮ ਦੇ ਹੇਠਾਂ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਸੈੱਲ ਦੇ ਟਾਇਟਰਾਂ ਦੇ ਤੌਰ ਤੇ ਸਿਰਲੇਖ ਦੀ ਵਰਤੋਂ ਕਰੋ ਸੀਐਸਵੀ :: ਦੀ ਸ਼ਕਤੀ ਦੀ ਗਵਾਹੀ :: ਕਤਾਰ :

     ਮਹਿਮਾਨ = CSV. foreach ('ਮਹਿਮਾਨ. csv', ਹੈਡਰ: ਸਹੀ) ਕਰਨਾ | ਕਤਾਰ |['ਨਾਂ'] ਕਤਾਰ ਲਿਖਦਾ ਹੈ # ਹਰੇਕ ਕਤਾਰ ਲਈ, ਮੈਨੂੰ 'ਨਾਮ' ਕਾਲਮ ਦੇ ਹੇਠਲੇ ਸੈੱਲ ਦਿਓਅੰਤ # => ਆਉਟਪੁੱਟ "ਦਾਨ", "ਮਾਰੀਆ", "ਕਾਰਲੋਸ", "ਸਟੈਫਨੀ" ਅਲੱਗ ਲਾਈਨਾਂ ਤੇ. "ਨਾਮ" ਛਾਪਿਆ ਨਹੀਂ ਜਾਂਦਾ.     

ਸੰਪੂਰਨ! ਸੀਐਸਵੀ :: ਰੋਲ ਦੀ ਆਪਣੀ ਸੁਵਿਧਾਜਨਕ ਢੰਗ ਹਨ, ਜਿਵੇਂ ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ. ਇਸ ਕੇਸ ਵਿੱਚ, ਦੂਜੀ ਕਤਾਰ ਸਿਰਫ ਕਤਾਰ ਲਈ ਸੰਕੀਰਣ ਖੰਡ ਹੈ [] ('ਨਾਮ') ਜੋ ਕਿ ਸਾਰੀਆਂ ਕਤਾਰਾਂ ਵਿਚ ਲੂਪ ਅਤੇ 'ਨਾਮ' ਕਾਲਮ ਦੇ ਅਧੀਨ ਹਨ, ਕੇਵਲ ਉਨ੍ਹਾਂ ਸੈੱਲਾਂ ਨੂੰ ਹੀ ਆਉਟਪੁੱਟ ਦੇਵੇਗਾ. ਤੁਸੀਂ ਦੂਜੇ ਕਾਲਮਾਂ ਦੇ ਅਨੁਸਾਰੀ ਮੁੱਲਾਂ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ 'ਨਾਮ' ਨੂੰ 'ਟਾਈਮਜ਼ ਆਉਡ', 'ਕੁੱਲ ਖਰਚਿਆ ਗਿਆ' ਜਾਂ 'ਫੀਡ ਫੀਡਬੈਟ' ਨਾਲ ਬਦਲ ਸਕਦੇ ਹੋ. ਯਾਦ ਰੱਖਣ ਵਾਲੀ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਗੱਲ ਇਹ ਹੈ ਕਿ ਸਿਰਲੇਖ ਦੇ ਨਾਮ ਕੇਸ ਸੰਵੇਦਨਸ਼ੀਲ ਹਨ. ਇਹ ਕੰਮ ਨਹੀਂ ਕਰੇਗਾ:

     ਮਹਿਮਾਨ = CSV. foreach ('ਮਹਿਮਾਨ. csv', ਹੈਡਰ: ਸਹੀ) ਕਰਨਾ | ਕਤਾਰ |['ਫ਼ੂਡ ਫੀਡਬੈਕ'] # => ਸਾਰੀਆਂ ਕਤਾਰਾਂ ਲਈ ਨੀਲ ਪ੍ਰਿੰਟ ਕਰੇਗੀ, ਸਹੀ ਕਾਲਮ ਦਾ ਨਾਂ 'ਫੂਡ ਫੀਡਬੈਕ' ਹੈਅੰਤ     

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

ਜੇ ਅਸੀਂ

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

     ਮਹਿਮਾਨ = CSV. ਪੜੋ ('ਮਹਿਮਾਨ. ਸਿਰਲੇਖ # => ["ਨਾਮ", "ਟਾਈਮਜ਼ ਆ ਪਹੁੰਚਿਆ", "ਕੁੱਲ ਖਰਚੇ ਗਏ", "ਫੂਡ ਫੀਡਬੈਕ"]     

ਇਹ ਸੀਐਸਵੀ :: ਸਾਰਣੀ # ਮਿਟਾਓ ਵਿਧੀ ਸੀਐਸਵੀ :: ਸਾਰਣੀ ਆਬਜੈਕਟ ਤੋਂ ਇੱਕ ਪੂਰਾ ਕਾਲਮ ਮਿਟਾ ਦੇਵੇਗੀ ਅਤੇ ਇਕ ਐਰੇ ਦੇ ਰੂਪ ਵਿੱਚ ਮਿਟਾਈਆਂ ਗਈਆਂ ਐਂਟਰੀਆਂ ਵਾਪਸ ਕਰ ਦੇਵੇਗਾ.

     ਮਹਿਮਾਨ ("ਦਾਨੀ", "ਮਾਰੀਆ", "ਕਾਰਲੋਸ", "ਸਟੈਫ਼ਨੀ"]     
ਨੂੰ ਹਟਾਓ ('ਨਾਮ') # =>

ਕੀ ਅਸੀਂ ਐਰੇ ਦੀ ਬਜਾਏ ਇਕ ਕਤਾਰ ਨੂੰ ਮਿਟਾਉਣਾ ਚਾਹੁੰਦੇ ਹਾਂ? ਅਸੀਂ ਇੱਕੋ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਾਂ ਮਿਟਾਓ ਵਿਧੀ, ਇਸ ਸਮੇਂ, ਇੱਕ ਸੰਖਿਆਤਮਕ ਸੂਚਕਾਂਕ (0 ਅਧਾਰਿਤ, ਇਸ ਲਈ 0 = ਪਹਿਲੀ ਕਤਾਰ, 1 = ਦੂਜੀ ਕਤਾਰ) ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ. ਰਿਟਰਨ ਵੈਲਯੂ, ਜਿਵੇਂ ਕਿ ਉਪਰੋਕਤ ਉਦਾਹਰਣ ਨਾਲ, ਹਟਾਇਆ ਗਿਆ ਕਤਾਰ ਹੋਵੇਗੀ.

     ਮਹਿਮਾਨ ਮਿਟਾਓ   # ਇਹ ਤਰੀਕਾ ਰਿਟਰਨ #        

ਇੱਥੇ ਉਹ ਥਾਂ ਹੈ ਜਿੱਥੇ ਕੁਝ ਥੋੜਾ ਵਿਅਰਥ ਹੋ ਜਾਂਦੀਆਂ ਹਨ ਜੇਕਰ ਤੁਸੀਂ ਐਰੇ ਅਤੇ ਹੈਸ਼ ਤੋਂ ਜਾਣੂ ਹੋ ਤਾਂ ਜਦੋਂ ਤੁਹਾਡੇ ਕੋਲ CSV :: ਸਾਰਣੀ ਇੱਕ ਵੇਰੀਏਬਲ ਵਿੱਚ, ਇੱਕ ਕਾਲਮ ਵਿੱਚ ਮੁੱਲਾਂ ਨੂੰ ਐਕਸੈਸ ਕਰਨ ਲਈ, ਜੋ ਤੁਸੀਂ ਕਾਲਮ ਨਾਮ ਨੂੰ ਇੰਡੈਕਸ ਦੇ ਤੌਰ ਤੇ ਵਰਤਦੇ ਹੋ ਅਤੇ ਇੱਕ ਲਾਈਨ ਤਕ ਪਹੁੰਚ ਕਰਨ ਲਈ ਤੁਸੀਂ 0 (0 - ਪਹਿਲੀ ਕਤਾਰ, 1 - ਦੂਜੀ ਕਤਾਰ ਆਦਿ):

     ਮਹਿਮਾਨ = CSV. ਪੜ੍ਹੋ ('ਮਹਿਮਾਨ. csv', ਸਿਰਲੇਖ: ਸਹੀ)ਮਹਿਮਾਨ ['ਟਾਈਮਜ਼'] # => ["34", "55", "22", "34"]ਮਹਿਮਾਨ "[0] # => #   >     

ਅਸੀਂ ਇਨ੍ਹਾਂ 2 ਸੰਕੇਤਾਂ ਨੂੰ ਜੋੜ ਸਕਦੇ ਹਾਂ ਕੇਵਲ ਇਕ ਵਿਸ਼ੇਸ਼ ਸੈੱਲ ਦੀ ਵਰਤੋਂ ਕਰਨਾ:

     ਮਹਿਮਾਨ ['ਟਾਈਮਜ਼' '] [1] # => ਰਿਟਰਨ' 55 'ਮਹਿਮਾਨ [1] ['ਟਾਈਮ ਆਈ ਹੈ'] # => ਵੀ 55     
ਰਿਟਰਨ ਕਰਦਾ ਹੈ

ਤੁਸੀਂ ਇਸ ਕੋਡ ਨਾਲ ਰੂਬੀ ਨੂੰ ਕੀ ਕਹਿ ਰਹੇ ਹੋ: "ਮੈਨੂੰ ਦੂਜੀ ਕਤਾਰ 'ਟਾਈਮਜ਼ ਆਜ਼ਡ' ਕਾਲਮ ਦੇ ਅਧੀਨ ਹੋਣ ਵਾਲੇ ਸੈਲ ਦਾ ਮੁੱਲ ਦਿਓ". ਸਾਫ਼!

ਸੀਐਸਵੀ ਹੈਡਰ ਦੀ ਵਿਹਾਰਕ ਵਰਤੋਂ

ਆਉ ਆਪਣੇ ਮਹਿਮਾਨਾਂ ਨੂੰ ਲੈਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ. csv ਫਾਇਲ ਅਤੇ "ਕੁੱਲ $ ਬਿਤਾਇਆ" ਕਾਲਮ ਨੂੰ ਬਦਲਣਾ ਤਾਂ ਜੋ ਇਸਦੇ ਪੂਰੇ ਅੰਕ ਦੀ ਬਜਾਏ ਦਸ਼ਮਲਵ ਹੋਵੇ:

     new_guests_csv = [] # ਅਸੀਂ ਨਵੇਂ ਸੀਐਸਵੀ ਡੇਟਾ ਨੂੰ ਸੋਨੇ ਦੇ ਰੂਪ ਵਿੱਚ ਤਿਆਰ ਕਰਦੇ ਹਾਂCSV. foreach ('ਮਹਿਮਾਨ. csv', ਸਿਰਲੇਖ: ਸਹੀ) ਕਰਦੇ ਹਨ | ਮਹਿਮਾਨ | # ਸਾਡੀ ਸੀਐਸਵੀ ਫਾਈਲ ਦੇ ਹਰੇਕ ਕਤਾਰ 'ਤੇ ਪੁਨਰ ਗਠਿਤਮਹਿਮਾਨ ['ਕੁਲ $ ਖਰਚ'] = ਮਹਿਮਾਨ ['ਕੁਲ $ ਖਰਚ']. to_f #new_guests_csv << ਪ੍ਰਾਹੁਣੇ # ਨਵੀਂ ਲਾਈਨ ਨੂੰ new_guests_csv ਵਿੱਚ ਜੋੜੋਅੰਤ     

ਮੈਂ ਨੂੰ ਵਰਤਣ ਦਾ ਫੈਸਲਾ ਕੀਤਾ ਹੈ. ਫੋਰਚ ਫਾਈਲ ਨੂੰ ਇੱਥੇ ਪੜ੍ਹਣ ਦਾ ਤਰੀਕਾ. ਮੈਂ ਇਹ ਵੀ ਵਰਤ ਸਕਦਾ ਸੀ ਸੀਐਸਵੀ # ਪੜ੍ਹੋ ਦੇ ਨਾਲ ਨਾਲ:

     new_guests_csv = [] # ਅਸੀਂ ਨਵੇਂ ਸੀਐਸਵੀ ਡੇਟਾ ਨੂੰ ਸੋਨੇ ਦੇ ਰੂਪ ਵਿੱਚ ਤਿਆਰ ਕਰਦੇ ਹਾਂold_guests_csv = CSV. ('ਮਹਿਮਾਨ. csv', ਸਿਰਲੇਖ: ਸਹੀ) ਪੜ੍ਹੋ CSV ਦੀ ਸੰਪੂਰਨ ਸਮੱਗਰੀ ਨੂੰ ਵੇਰੀਏਬਲ ਵਿੱਚ ਪੜ੍ਹੋold_guests_csv. ਹਰ ਇੱਕ ਕਰਦੇ ਹਨ | ਮਹਿਮਾਨ | # old_guests_csv ਸੀਐਸਵੀ :: ਸਾਰਣੀ ਆਬਜੈਕਟ ਜਿਸ ਦੀਆਂ ਆਪਣੀਆਂ ਕਤਾਰਾਂ 'ਤੇ ਮੁੜ ਦੁਹਰਾਉਣ ਲਈ # ਤਰੀਕਾ ਹੈਮਹਿਮਾਨ ['ਕੁਲ $ ਖਰਚ'] = ਮਹਿਮਾਨ ['ਕੁਲ $ ਖਰਚ']. to_f # ਸਾਡੇ ਪਿਛਲੇ ਕੋਡ ਦੇ ਨਾਲ ਹੀ ਇਕੋ ਗੱਲ ਹੈnew_guests_csv << ਪ੍ਰਾਹੁਣੇ # ਨਵੀਂ ਲਾਈਨ ਨੂੰ new_guests_csv ਵਿੱਚ ਜੋੜੋਅੰਤ     

ਅਸੀਂ ਇਹ ਕਰ ਸਕਦੇ ਹਾਂ ਜੇ ਅਸੀਂ ਨਵੀਂ ਡਾਟਾ ਵਿੱਚ ਆਪਣਾ ਡਾਟਾ ਸੁਰੱਖਿਅਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ:

     ਸੀਐਸਵੀ ਖੋਲੋ ('ਅਪਡੇਟ_guests. csv', 'w') ਕਰੋ | csv | | # ਇਕ ਨਵੀਂ ਫਾਈਲ ਅਪਡੇਟ_ਗਰੇਟਸ ਬਣਾਓ ਸੀਐਸਵੀcsv << ['ਨਾਮ', 'ਟਾਈਮਜ਼ ਆ ਗਿਆ', 'ਕੁੱਲ ਖਰਚੇ (ਡੈਸੀਮਲ)', 'ਫੂਡ ਫੀਡਬੈਕ'] # ਨਵੇਂ ਸਿਰਲੇਖ ਸ਼ਾਮਲ ਕਰੋnew_guests_csv. ਹਰ ਇੱਕ ਕਰਦੇ ਹਨ |# ਕਿਉਂਕਿ ਹੁਣ ਸਾਡੇ ਕੋਲ ਇਸ ਵੇਰੀਏਬਲ ਵਿੱਚ ਸਾਰੀ ਨਵੀਨਤਮ CSV ਫਾਈਲ ਹੈ, ਇੱਕ ਡਬਲ ਐਰੇ ਦੇ ਤੌਰ ਤੇ,# ਅਸੀਂ ਹਰ ਇੱਕ (ਐਰੇ) ਤੱਤ ਤੇ ਰੁਕੇ ਹਾਂਸੀਐਸਵੀ ਕਤਾਰ ਨੂੰ ਰੱਖਦਾ ਹੈਅੰਤਅੰਤ     

ਅਕਸਰ, ਜਦੋਂ ਇੱਕ ਨਵੀਂ CSV ਫਾਈਲ ਵਿੱਚ ਡਾਟਾ ਲਿਖਦੇ ਹੋ, ਤੁਸੀਂ ਆਪਣੇ ਸਿਰਲੇਖ ਨਾਮਾਂ ਨੂੰ ਬਦਲਣਾ ਚਾਹੁੰਦੇ ਹੋਵੋਗੇ ਸਭ ਤੋਂ ਵੱਧ ਲੋਕ ਕੀ ਕਰਦੇ ਹਨ, ਪਹਿਲਾਂ, ਨਵੇਂ ਸਿਰਲੇਖ ਜੋੜਦੇ ਹਨ (ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਉੱਪਰ ਦੂਜੀ ਲਾਈਨ ਤੇ ਕੀਤਾ) ਅਤੇ, ਫਿਰ, ਸੋਧੇ ਹੋਏ ਵੇਰੀਏਬਲ (ਸਾਡੇ ਕੇਸ new_guests_csv ) ਵਿੱਚ ਪਾਓ ਅਤੇ ਹਰੇਕ ਲਾਈਨ ਨੂੰ ਅਲੱਗ ਅਲੱਗ ਕਰੋ.

ਤੇਜ਼ ਟਿਪ: ਕੀ ਤੁਹਾਡੇ ਕੋਲ 2 ਇਸੇ ਕਾਲਮ ਨਾਮਾਂ ਵਾਲੀ ਇੱਕ ਫਾਈਲ ਸੀ? ਮੰਨ ਲਓ ਕਿ ਸਾਡੇ ਮਹਿਮਾਨ ਸੀ ਐਸ ਵੀ ਫਾਈਲ ਵਿੱਚ ਹੋਰ 'ਨਾਮ' ਕਾਲਮ ਮੌਜੂਦ ਹੈ, ਅਸੀਂ ਇਸਨੂੰ ਕਿਵੇਂ ਵਰਤ ਸਕਦੇ ਹਾਂ? ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਜਾਣਦੇ ਹੋ, ਪਹਿਲੇ ਕਾਲਮ ਨੂੰ row_object ['name'] ਨਾਲ ਐਕਸੈਸ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ. ਇਸ ਤਰ੍ਹਾਂ, ਕਾਰਗੁਜ਼ਾਰੀ ਸੈਕੰਡਰੀ ਹੈ ਅਤੇ ਤਰਜੀਹ ਸੂਚੀ ਵਿੱਚ ਸਹੂਲਤ ਪਹਿਲੀ ਹੈ. ਮਿਡਲ, ਇਹ ਇੱਕ ਸਮੱਸਿਆ ਹੋ ਸਕਦੀ ਹੈ ਜਦੋਂ ਤੁਸੀਂ ਕੋਈ ਵੱਡੀ ਫਾਈਲ ਮੈਮਰੀ ਵਿੱਚ ਪੜ੍ਹਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਰਹੇ ਹੋ ਜੇ ਤੁਹਾਡੀ ਫਾਈਲ 300 ਮੈਗਾਬਾਇਟਸ ਹੈ ਅਤੇ ਤੁਹਾਡੇ ਕੋਡ ਨੂੰ ਚਲਾਉਣ ਵਾਲੀ ਮਸ਼ੀਨ, 512 ਮੈਬਾ ਦੀ ਰੈਮ, ਤਾਂ ਕੋਈ ਸਮੱਸਿਆ ਹੋਣੀ ਹੈ.

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

     # ਕੁਝ ਨਿਯਮਤ ਸਮਗਰੀ ਬਣਾਉਂਦੇ ਹੋਏ, ਪ੍ਰੋਗਰਾਮ ਮੈਮਰੀ ਦਾ ਆਕਾਰ 12MB ਹੁੰਦਾ ਹੈਮਹਿਮਾਨ = CSV ('ਮਹਿਮਾਨ. csv', ਸਿਰਲੇਖ: ਸਹੀ) ਪੜ੍ਹੋ # ਇੱਕ ਵੱਡੀ CSV ਫਾਈਲ ਨੂੰ ਮੈਮਰੀ ਵਿੱਚ ਪੜ੍ਹਿਆ ਜਾਂਦਾ ਹੈ, ਆਕਾਰ ਹੁਣ 100MB ਤੋਂ ਵੱਧ ਹੈ!ਮਹਿਮਾਨ do | row | ਚੁਣੋਕਤਾਰ ['ਟਾਈਮਜ਼'] to_i> 10 # ਜੇ ਅਸੀਂ ਇਕ ਹੋਰ ਵੇਰੀਏਬਲ ਵਿਚਲੇ ਚੁਣੇ ਬਲਾਕ ਦੇ ਰਿਟਰਨ ਵੈਲਯੂ ਨੂੰ ਪਾਉਂਦੇ ਹਾਂ, ਤਾਂ ਸਾਡੇ ਕੋਲ ਵੱਡੇ ਸਾਈਜ਼ ਵੀ ਹੋਵੇਗਾਅੰਤ     

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

     ਮਹਿਮਾਨ_ਸਵੈ_ਵੈਸਟ ਕੀਤੇ_ਮੌਜੀ_ਥਾਂ_ਤੇ_ਟਾਈਮਸ = ਅਰੇ ਨਵਾਂCSV. foreach ('ਮਹਿਮਾਨ. csv', ਸਿਰਲੇਖ: ਸਹੀ) ਕਰਦੇ ਹਨ | ਮਹਿਮਾਨ |guest_who_visited_more_than_ten_times < < ਮਹਿਮਾਨ ਜੇ ਮਹਿਮਾਨ ['ਟਾਈਮਜ਼']>  10ਅੰਤ     

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

     ਸੀਐਸਵੀ ਖੋਲੋ ('ਮਹਿਮਾਨ. csv', ਹੈਡਰ: ਸਹੀ) ਕਰਦੇ | ਮਹਿਮਾਨ |ਮਹਿਮਾਨ = ਮਹਿਮਾਨ ਹਰੇਕਮਹਿਮਾਨ do | row | ਚੁਣੋਕਤਾਰ ['ਟਾਈਮਜ਼'] to_i> 10ਅੰਤਅੰਤ     

ਜੇਕਰ ਤੁਸੀਂ ਦੂਜੀ ਲਾਈਨ ਤੋਂ ਜਾਣੂ ਨਹੀਂ ਹੋ, ਤਾਂ ਅਸੀਂ ਅਸਲ ਵਿੱਚ ਇੱਕ ਗਣਿਤ ਇਕਾਈ ਬਣਾਉ ਅਤੇ ਇਸ ਨੂੰ ਮਹਿਮਾਨ ਵੇਰੀਏਬਲ ਵਿੱਚ ਸਟੋਰ ਕਰੋ. ਗਿਣਤੀਕਾਰ ਸਾਨੂੰ "ਮੰਗ ਤੇ" ਦੁਹਰਾਉਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੇ ਹਨ, ਕਹਿਣਾ, ਜੇਕਰ ਮੇਰੇ ਕੋਲ ਕੋਡ ਸੀ ਜੋ 1 ਤੋਂ 100 ਤੱਕ ਗਿਣਿਆ ਜਾਂਦਾ ਹੈ:

     1. ਤੱਕ  

{| x | p x}

ਇਸ ਨੂੰ ਇੱਕ ਗਣਨਾ ਵਾਲੀ ਵਸਤੂ ਵਿੱਚ ਮਿਣਨ ਨਾਲ, ਮੈਨੂੰ, ਮੇਰੇ ਪ੍ਰੋਗਰਾਮ ਦੇ ਇੱਕ ਹਿੱਸੇ ਵਿੱਚ 1 ਤੋਂ 5 ਤੱਕ ਗਿਣਨਾ ਹੋਵੇਗਾ ਅਤੇ ਫਿਰ, ਬਾਅਦ ਵਿੱਚ 10 ਦੀ ਗਿਣਤੀ ਨੂੰ ਖਤਮ ਕਰਨਾ:

     enum = 1. ਤੋਂ  

p enum. ਅਗਲੇ # => 1ਪੀ 'ਇੱਥੇ ਹੋਰ ਕੋਡ ਦਾ ਝੁੰਡ'p enum. ਅਗਲੇ # => 2ਪੀ 'ਅਤੇ ਇੱਥੇ'p enum. ਅਗਲੇ # => 3

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

ਠੀਕ ਹੈ, ਇਹ ਰੂਬੀ ਸੀਐਸਵੀ ਸੀਰੀਜ਼ ਦਾ ਅੰਤ ਹੈ. ਮੈਨੂੰ ਉਮੀਦ ਹੈ ਤੁਸੀਂ ਬਹੁਤ ਕੁਝ ਸਿੱਖਿਆ ਹੈ!

March 7, 2018