क्या आप इस रूबी कोड में क्या हो रहा है समझा सकते हैं?

Question

मैं रूबी के साथ-साथ रेल पर रूबी सीखने की कोशिश कर रहा हूं। मैं लर्निंग रेल, 1 संस्करण के साथ पीछा कर रहा हूं, लेकिन मुझे कुछ कोड समझने में कठिनाई हो रही है।

मैं आमतौर पर सी, सी ++, या जावा में काम करता हूं, इसलिए रूबी मेरे लिए एक बहुत बड़ा बदलाव है।

मैं वर्तमान में एक डेटाबेस migrator के लिए निम्न कोड ब्लॉक के साथ स्टम्प्ड हूँ:

def self.up 
    create_table :entries do |t| 
     t.string :name 
     t.timestamps 
    end 
    end 

कहाँ टी चर आ रहा है से? यह वास्तव में क्या प्रतिनिधित्व करता है? क्या यह 'i' की तरह है (i = 0; i < 5; i ++) कथन?

इसके अलावा, कहां परिभाषित किया जा रहा है? (प्रविष्टियां मेरे नियंत्रक का नाम है, लेकिन इस फ़ंक्शन को इसके बारे में कैसे पता चलता है?)

Answer 1

:entries, एक प्रतीक शाब्दिक है यह 7 या "a string" की तरह एक शाब्दिक मूल्य है। परिभाषित करने के लिए कुछ भी नहीं है (आकस्मिक रूप से, फ़ंक्शन आपके नियंत्रक के नाम के बारे में नहीं जानता है)।

t आपके द्वारा create_tables विधि में पारित किए गए ब्लॉक का पैरामीटर है।जो आपने यहां लिखा है वह लगभग कुछ समान है:

void anonymous_block(Table *t) { 
    t->string("name"); 
    t->timestamps(); 
} 

... 

create_table("entries", &anonymous_block); 

सी ++ में। create_table आपके ब्लॉक को कॉल करता है और इसे एक पैरामीटर पास करता है, जिसे आपने t नाम दिया है। मैं सुझाव दूंगा कि आपको रेल के विपरीत ruby ​​ के लिए एक प्रारंभिक पुस्तक मिल जाएगी। मैं डेविड ए ब्लैक द्वारा रेल के लिए रूबी की अनुशंसा करता हूं।

Answer 2

create_table वह तरीका है जो लैम्ब्डा अभिव्यक्ति (प्रतिनिधि के कुछ प्रकार) स्वीकार करता है, टी प्रतिनिधि का तर्क है। तो जब आप create_table निष्पादित निष्पादित

t.string :name 
t.timestamps 

कुछ छद्म कोड की तरह

delegate d = funciton (t) { 
    t.string :name 
    t.timestamps 
} 
create_table(d); 

जावा में

प्रत्यक्ष अनुरूप anonimous वर्गों है ..

addReturnBackListener(new Listener<EventObject>() { 
    public void handle(EventObject e) { 
    refreshAndShowAndList(); 
    } 
}); 

": प्रविष्टियों" बिल्कुल परिभाषित नहीं है , यह सिर्फ पहचानकर्ता है। आप इसे सरल स्ट्रिंग के रूप में देख सकते हैं (लेकिन वर्ण रखने पर स्मृति खर्च किए बिना)।

Answer 3

मैं t चीज़ ले जाऊंगा। create_table विधि एक सी समारोह है कि एक समारोह सूचक है कि एक तर्क, टेबल परिभाषा वस्तु लेता है लेता है (मेरे न के बराबर सी कौशल माफ) की तरह है:

void entries_table_constructor(TableDef table_definition) { 
    table_def_add_string_column(table_definition, "name"); 
    table_def_add_timestamps_column(table_definition); 
}  

create_table("entries", entries_table_constructor); 

लेकिन रूबी में पारित समारोह की परिभाषा कर सकते हैं इस समय create_table विधि कहा जाता है। तो do और end के बीच बिट entries_table_constructor फ़ंक्शन की तरह है, और t चर table_definition तर्क की तरह है।

हालांकि रू में फ़ंक्शन पॉइंटर्स और रूबी में ब्लॉक के बीच एक बड़ा अंतर है। रूबी में, ब्लॉक के बाहर सभी स्थानीय चर ब्लॉक के अंदर उपलब्ध हैं: कैसे create_table की तरह अपने स्वयं के तरीकों लिखने के लिए देखने के लिए

a = 10 
create_table :entries do |t| 
    puts a 
    ... 
end 

बाहर रूबी में yield कीवर्ड चेक।

Answer 4

यह रूबी में ब्लॉक का सामान्य उपयोग है। विधि create_table तरह ActiveRecord में परिभाषित किया गया है:

def create_table(table_name) 
    table_object = some_table_setup 
    yield(table_object) # your code block which was passed implicitly is invoked here 
    create_table(table_object) 
end 

Answer 5

: प्रविष्टियां रेल में प्रविष्टियों तालिका का संदर्भ है।

migrator इसके बारे में जाना जाता है | जब 'नियंत्रक उत्पन्न' कमांड जहाँ तक मैं समझता हूँ कि दिया गया था (एक वर्ष के लिए पेशेवर रेल के साथ काम किया है, लेकिन, अभी भी सीख रहा)।

के लिए | टी | वह एक ब्लॉक है। कुदाल से मिट्टी खुरपना पुस्तक (जो या तो आप पीडीएफ या मृत पेड़ संस्करण की एक प्रति तुरंत मिलना चाहिए) के शब्दों में:

ब्लाकों कोड है कि लेन-देन संबंधी नियंत्रण के कुछ प्रकार के तहत चलाए किया जाना चाहिए का एक हिस्सा परिभाषित करने के लिए इस्तेमाल किया जा सकता। उदाहरण के लिए, आप अक्सर एक फ़ाइल खोलेंगे, इसकी सामग्री के साथ कुछ करें, और फिर यह सुनिश्चित करना चाहते हैं कि फ़ाइल समाप्त होने पर बंद हो। यद्यपि आप पारंपरिक कोड का उपयोग करके ऐसा कर सकते हैं, फ़ाइल को स्वयं बंद करने के लिए जिम्मेदार बनाने के लिए एक तर्क है। हम इसे ब्लॉक के साथ कर सकते हैं।

तो, ऊपर के साथ क्या चल रहा है यह है कि | टी | वह ब्लॉक है जो डाटाबेस से कनेक्शन स्थापित करता है, पंक्तियों को उनके विशिष्ट प्रकारों के अनुसार बनाता है, और फिर कनेक्शन बंद कर देता है।

यहाँ एक और उदाहरण है:

output_string = "Let's print this to file" 

File.open('outputfile.txt','w') do |f| #f for file 
    f.print output_string 
end 

अपने इटरेटर का सवाल है, हाँ आप के रूप में अच्छी तरह से है कि कर सकते हैं:

an_array = [1,2,3,4] 
an_array.each do |line|#line is the block for the elements of the array during iteration 
    puts "Now we are at: #{line.to_s}!" 
end 

Answer 6

create_table विधि क्या रूबी में एक ब्लॉक के रूप में जाना जाता है और t है एक चर जो उस ब्लॉक के लिए स्थानीय है (t रेल की माइग्रेशन में केवल एक सम्मेलन है जो "टेबल" के लिए खड़ा है)।

10.times do |i| 
    print "i is #{i}" 
end 

:entries एक रूबी प्रतीक है, जो हल्के स्ट्रिंग है कि चीजें नामकरण के लिए प्रयोग किया जाता है का एक प्रकार है: यह एक रूबी ब्लॉक का एक और अधिक स्पष्ट उदाहरण है। आप समान रूप से "entries" का उपयोग कर सकते थे। प्रतीकों का एक आम उपयोग हैश में चाबियाँ निर्दिष्ट करने के लिए है। किसी भी मामले में, बनाई जा रही तालिका को "प्रविष्टियां" नाम दिया गया है।

Answer 7

प्रविष्टियों अपने एंट्री मॉडल के संदर्भ में है - प्रत्येक मॉडल मानता है कि तालिका नाम को छोड़कर tableized (http://api.rubyonrails.org/classes/ActiveSupport/CoreExtensions/String/Inflections.html#M001653)

टी एक ब्लॉक पैरामीटर create_table विधि में नीचे पारित कर दिया है कि इसके नाम के रूप में ही हो जाएगा, देखना एक बेहतर उदाहरण के लिए http://www.rubycentral.com/book/tut_containers.html। इस मामले टी में बनाया गया है कि तालिका (http://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#M002191)

उम्मीद है कि है कि आप मदद करने के लिए

Answer 8

मैं भी एक Entry मॉडल/entries टेबल है जिसे किसी एप्लिकेशन पर काम के लिए हो पर्याप्त होना चाहिए मतलब है।यहां मेरा माइग्रेशन है:

class CreateEntries < ActiveRecord::Migration 
    def self.up 
    create_table :entries do |t| 
     t.string :title 
     t.text :entry 
     # ... 
    end 
    end 

    def self.down 
    drop_table :entries 
    end 
end 

आप जो देख रहे हैं उसके समान ही।

सबसे पहले, पहली पंक्ति, CreateEntries नामक एक वर्ग घोषित करें जो ActiveRecord::Migration फैली हुई है।

अगला, up() नामक एक क्लास विधि घोषित करना। एक वर्ग विधि, उदाहरण के विपरीत एक वर्ग विधि वर्ग की विशिष्ट वस्तुओं के बजाय कक्षा से संबंधित है। यह "self" कीवर्ड है जो इसे क्लास विधि बनने का कारण बनता है।

अगला create_table() बुला और यह दो बातें गुजर:

1. एक प्रतीक (":entries") जो, जैसा कि ऊपर उल्लेख किया है, एक स्ट्रिंग शाब्दिक की तरह है। यह ActiveRecord को बताता है कि यह किस तालिका को बनाता है उसे कॉल किया जाना चाहिए। आइए मान लें कि आपने यह कोड हाथ से टाइप किया है - जेनरेटर के बारे में एक मिनट के लिए भूल जाओ। आपने ":entries" टाइप किया है क्योंकि आप जानते हैं कि एक रेल ऐप में सम्मेलन तालिकाओं द्वारा बहुवचन संज्ञाओं के साथ नामित किया गया है, और आप जानते हैं कि इस तालिका में जो मॉडल क्लास है, उसे Entry कहा जाएगा।

2. भी एक ब्लॉक पास।

एक ब्लॉक से ...

`do ... end` 

या

`{ ... }` 

से एक ब्लॉक संलग्न किया जा सकता है दो "|" एस से घिरा मापदंडों ले सकते हैं। इस मामले में create_table विधि ब्लॉक TableDefinition के किसी ऑब्जेक्ट को ब्लॉक करने के लिए गुजर रही है, इसलिए अपने प्रश्नों में से किसी एक का उत्तर देने के लिए, t ऑब्जेक्ट उस var होल्डिंग है। फिर ब्लॉक के अंदर, हम TableDefinition के विभिन्न उदाहरण विधियों को बुला रहे हैं।

TableDefinition ऑब्जेक्ट कहां से आया? यह create_table() विधि में होता है। यह कोड है कि एक नए TableDefinition वस्तु और ब्लॉक करने के लिए "पैदावार" यह को दर्शाता है ....

ActiveRecord स्रोत कोड ...

def create_table(table_name, options = {}) 
    table_definition = TableDefinition.new(self) 
    table_definition.primary_key(options[:primary_key] || "id") unless options[:id] == false 

    yield table_definition 

    # ... 

end 

Answer 9

शामिल हैं: entries वहीं परिभाषित किया जा रहा है। कोड दो तर्कों के साथ विधि create_table को कॉल कर रहा है - तालिका का वांछित नाम, और कोड का एक ब्लॉक।

create_table TableDefinition ऑब्जेक्ट का निर्माण करेगा और फिर उस ऑब्जेक्ट को उस ऑब्जेक्ट की आपूर्ति करने के लिए कोड के ब्लॉक को उपज देगा। कोड के ब्लॉक के भीतर इसे t नाम दिया जाएगा। और आखिर में कोड का ब्लॉक कॉलम बनाने के लिए t पर कुछ विधियों को कॉल करता है।

Answer 10

चूंकि, पायथन से आ रहा है, इसलिए मुझे यह समझने में संघर्ष हुआ कि मैं खुद ही निर्माण कर रहा हूं, मैं आपके कोड स्निपेट का अवांछित अनुवाद दूंगा।

सबसे पहले, आप इस एक के रूप में एक समारोह create_table को परिभाषित करने के लिए होता है (यह सिर्फ एक कंकाल है):

def create_table(name, setup): 
    t = Table(name) 
    setup(t) 

, फिर प्रत्येक तालिका के लिए, आप के रूप में एक सेटअप समारोह बनाना होगा:

def setup_entries(t): # <-- here is your |t|, just a function argument 
    t.string("name") 
    t.timestamps() 

और अंत में आपको कॉल करके तालिका बनाने होगा:

create_table("entries", setup_entries) 

यह w नहीं है अरे यह पायथन के साथ किया जाएगा। यदि आप पाइथन में टेबल बनाने के तरीके में रुचि रखते हैं तो आपको यह देखना चाहिए कि django, या sqlalchemy इसे संभाल लें।