the_information_nexus/loops.md at e81d3bbc28b72acb3a829726a3156e4788ec4b4d

Files

medusa 34aff8e0d2 Add tech_docs/python/loops.md

2024-06-01 06:14:28 +00:00

4.2 KiB

Raw Blame History

Let's break down the concept of for page in pages in a more concrete manner, using a simple analogy and detailed examples to clarify its meaning.

Analogy

Imagine you have a bookshelf with several books on it. Each book represents an item, and the entire bookshelf represents a collection of items. If you wanted to look at each book one by one, you would take each book off the shelf, examine it, and then put it back. This is similar to how a loop works in programming.

Explanation

In programming, for page in pages is a loop that iterates over a collection called pages. Each individual item in pages is referred to as page during each iteration of the loop. Let's break this down with a concrete example in Python using Jinja2 (since it's more familiar to Python developers) and then translate it to Go templates.

Jinja2 Example (Python Templating)

Python Code:

from jinja2 import Template

# Data to be passed to the template
data = {
    'pages': [
        {'title': 'Home', 'content': 'Welcome to the homepage!'},
        {'title': 'About', 'content': 'About us page content'},
        {'title': 'Contact', 'content': 'Contact us here'}
    ]
}

# Template with a loop
template_str = """
<!DOCTYPE html>
<html>
<head>
  <title>Pages</title>
</head>
<body>
  <ul>
    {% for page in pages %}
      <li>
        <h2>{{ page.title }}</h2>
        <p>{{ page.content }}</p>
      </li>
    {% endfor %}
  </ul>
</body>
</html>
"""

# Create a template object and render it with the data
template = Template(template_str)
rendered_html = template.render(pages=data['pages'])

print(rendered_html)

Explanation of Jinja2 Example:

Data: We have a dictionary data with a key pages that contains a list of dictionaries. Each dictionary represents a page with a title and content.
Template: The template string contains HTML and Jinja2 syntax. The {% for page in pages %} loop iterates over each dictionary in pages.
Rendering: When the template is rendered with data, the loop generates HTML for each page, displaying its title and content.

Rendered HTML Output:

<!DOCTYPE html>
<html>
<head>
  <title>Pages</title>
</head>
<body>
  <ul>
    <li>
      <h2>Home</h2>
      <p>Welcome to the homepage!</p>
    </li>
    <li>
      <h2>About</h2>
      <p>About us page content</p>
    </li>
    <li>
      <h2>Contact</h2>
      <p>Contact us here</p>
    </li>
  </ul>
</body>
</html>

Go Template Example (Equivalent)

Now, let's translate the same example to Go templates.

Go Code:

package main

import (
	"html/template"
	"os"
)

type Page struct {
	Title   string
	Content string
}

func main() {
	// Data to be passed to the template
	pages := []Page{
		{Title: "Home", Content: "Welcome to the homepage!"},
		{Title: "About", Content: "About us page content"},
		{Title: "Contact", Content: "Contact us here"},
	}

	// Template with a loop
	const tmpl = `
<!DOCTYPE html>
<html>
<head>
  <title>Pages</title>
</head>
<body>
  <ul>
    {{ range . }}
      <li>
        <h2>{{ .Title }}</h2>
        <p>{{ .Content }}</p>
      </li>
    {{ end }}
  </ul>
</body>
</html>
`

	// Parse and execute the template
	t := template.Must(template.New("example").Parse(tmpl))
	err := t.Execute(os.Stdout, pages)
	if err != nil {
		panic(err)
	}
}

Explanation of Go Template Example:

Data: We have a slice of Page structs. Each struct represents a page with a Title and Content.
Template: The template string contains HTML and Go template syntax. The {{ range . }} loop iterates over each Page in the pages slice.
Rendering: When the template is executed with pages, the loop generates HTML for each page, displaying its title and content.

Conclusion

for page in pages (in Python/Jinja2) or {{ range . }} (in Go templates) is a way to loop through a collection of items.
Each iteration of the loop processes one item from the collection, allowing you to generate dynamic content based on each item's data.

By comparing the Jinja2 and Go template examples, you can see how the same concept of iterating over a collection is applied in different templating systems. This should help make the idea more concrete and understandable.

4.2 KiB Raw Blame History