restore wrongly overridden translation

Author: Madoshakalaka

website/i18n/ja/docusaurus-plugin-content-docs/version-0.21/advanced-topics/optimizations.mdx

@@ -1,13 +1,14 @@
 ---
-title: 'Optimizations & Best Practices'
+title: '最適化とベストプラクティス'
 sidebar_label: Optimizations
 description: 'Make your app faster'
 ---
 
-## Using smart pointers effectively
+## 効果的にスマートポインタを使う
 
-**Note: if you're unsure about some of the terms used in this section, the Rust Book has a useful
-[chapter about smart pointers](https://doc.rust-lang.org/book/ch15-00-smart-pointers.html).**
+**注意: このセクションで使われている用語がわからなければ Rust book は
+[スマートポインタについての章](https://doc.rust-lang.org/book/ch15-00-smart-pointers.html)
+があり、非常に有用です。**
 
 To avoid cloning large amounts of data to create props when re-rendering, we can use
 smart pointers to only clone a reference to the data instead of the data itself. If you pass
@@ -79,31 +80,29 @@ If your main crate is too heavyweight, or you want to rapidly iterate on a deepl
 a page that renders on top of another page\), you can use an example crate to create a simplified
 implementation of the main page and additionally render the component you are working on.
 
-## Reducing binary sizes
+## バイナリサイズを小さくする
 
-- optimize Rust code
-- `cargo.toml` \( defining release profile \)
-- optimize wasm code using `wasm-opt`
+- Rust のコードを最適化する
+- `cargo.toml` \( release profile を定義 \)
+- `wasm-opt`を用いて wasm のコードを最適化する
 
-**Note: more information about reducing binary sizes can be found in the
-[Rust Wasm Book](https://rustwasm.github.io/book/reference/code-size.html#optimizing-builds-for-code-size).**
+**注意: バイナリサイズを小さくするのについては[Rust Wasm Book](https://rustwasm.github.io/book/reference/code-size.html#optimizing-builds-for-code-size)に詳しく書いてあります。**
 
 ### Cargo.toml
 
-It is possible to configure release builds to be smaller using the available settings in the
-`[profile.release]` section of your `Cargo.toml`.
+`Cargo.toml`で`[profile.release]`のセクションに設定を書き込むことでリリースビルドを小さくすることが可能です。
 
 ```toml, title=Cargo.toml
 [profile.release]
-# less code to include into binary
+# バイナリに含むコードを少なくする
 panic = 'abort'
-# optimization over all codebase ( better optimization, slower build )
+# コードベース全体での最適化 ( 良い最適化だがビルドが遅くなる)
 codegen-units = 1
-# optimization for size ( more aggressive )
+# サイズの最適化( よりアグレッシブに )
 opt-level = 'z'
-# optimization for size
+# サイズの最適化
 # opt-level = 's'
-# link time optimization using using whole-program analysis
+# プログラム全体の分析によるリンク時最適化
 lto = true
 ```
 
@@ -133,31 +132,31 @@ that require occasional attention and tweaking. Use these experimental options w
 
 ### wasm-opt
 
-Further, it is possible to optimize the size of `wasm` code.
+更に`wasm`のコードのサイズを最適化することができます。
 
-The Rust Wasm Book has a section about reducing the size of Wasm binaries:
+The Rust Wasm Book には Wasm バイナリのサイズを小さくすることについてのセクションがあります:
 [Shrinking .wasm size](https://rustwasm.github.io/book/game-of-life/code-size.html)
 
-- using `wasm-pack` which by default optimizes `wasm` code in release builds
-- using `wasm-opt` directly on `wasm` files.
+- `wasm-pack`でデフォルトの`wasm`のコードをリリースビルド時に最適化する
+- `wasm-opt`によって直接`wasm`ファイルを最適化する
 
 ```text
 wasm-opt wasm_bg.wasm -Os -o wasm_bg_opt.wasm
 ```
 
-#### Build size of 'minimal' example in yew/examples/
+#### yew/examples/にある例を小さなサイズでビルドする
 
-Note: `wasm-pack` combines optimization for Rust and Wasm code. `wasm-bindgen` is used in this example without any Rust size optimization.
+注意: `wasm-pack`は Rust と Wasm のコードへの最適化を組み合わせます。`wasm-bindgen`はこの例では Rust のサイズ最適化を用いていません。
 
-| used tool                   | size  |
-| :-------------------------- | :---- |
-| wasm-bindgen                | 158KB |
-| wasm-bindgen + wasm-opt -Os | 116KB |
-| wasm-pack                   | 99 KB |
+| 使用したツール              | サイズ |
+| :-------------------------- | :----- |
+| wasm-bindgen                | 158KB  |
+| wasm-bindgen + wasm-opt -Os | 116KB  |
+| wasm-pack                   | 99 KB  |
 
-## Further reading:
+## 参考文献:
 
-- [The Rust Book's chapter on smart pointers](https://doc.rust-lang.org/book/ch15-00-smart-pointers.html)
-- [Information from the Rust Wasm Book about reducing binary sizes](https://rustwasm.github.io/book/reference/code-size.html#optimizing-builds-for-code-size)
-- [Documentation about Rust profiles](https://doc.rust-lang.org/cargo/reference/profiles.html)
-- [binaryen project](https://github.com/WebAssembly/binaryen)
+- [The Rust Book のスマートポインタに関する章](https://doc.rust-lang.org/book/ch15-00-smart-pointers.html)
+- [the Rust Wasm Book でのバイナリサイズを小さくすることについて](https://rustwasm.github.io/book/reference/code-size.html#optimizing-builds-for-code-size)
+- [Rust profiles についてのドキュメント](https://doc.rust-lang.org/cargo/reference/profiles.html)
+- [binaryen プロジェクト](https://github.com/WebAssembly/binaryen)

website/i18n/ja/docusaurus-plugin-content-docs/version-0.21/advanced-topics/struct-components/lifecycle.mdx

@@ -1,24 +1,22 @@
 ---
-title: 'Lifecycle'
-description: 'Components and their lifecycle hooks'
+title: 'ライフサイクル'
+description: 'コンポーネントとそのライフサイクルフック'
 ---
 
-The `Component` trait has a number of methods which need to be implemented; Yew will call these at different
-stages in the lifecycle of a component.
+`Component` トレイトには実装が必要なメソッドがいくつかあります。Yew はコンポーネントのライフサイクルの異なる段階でこれらを呼び出します。
 
-## Lifecycle
+## ライフサイクル
 
 :::important contribute
 `Contribute to our docs:` [Add a diagram of the component lifecycle](https://github.com/yewstack/yew/issues/1915)
 :::
 
-## Lifecycle Methods
+## ライフサイクルのメソッド
 
 ### Create
 
-When a component is created, it receives properties from its parent component and is stored within
-the `Context<Self>` that is passed down to the `create` method. The properties can be used to
-initialize the component's state and the "link" can be used to register callbacks or send messages to the component.
+コンポーネントが作られると、親コンポーネントからプロパティを受け取り、`create` メソッドに渡される `Context<Self>` 内に格納されます。
+プロパティはコンポーネントの状態を初期化するのに使われ、"link"はコールバックを登録したりコンポーネントにメッセージを送るのに使われます。
 
 ```rust
 use yew::{Component, Context, html, Html, Properties};
@@ -48,12 +46,10 @@ impl Component for MyComponent {
 
 ### View
 
-The `view` method allows you to describe how a component should be rendered to the DOM. Writing
-HTML-like code using Rust functions can become quite messy, so Yew provides a macro called `html!`
-for declaring HTML and SVG nodes (as well as attaching attributes and event listeners to them) and a
-convenient way to render child components. The macro is somewhat similar to React's JSX (the
-differences in programming language aside).
-One difference is that Yew provides a shorthand syntax for properties, similar to Svelte, where instead of writing `onclick={onclick}`, you can just write `{onclick}`.
+コンポーネントは`view()`メソッドによってレイアウトを宣言します。
+Yew は`html!`マクロによって HTML と SVG ノード、リスナー、子コンポーネントを宣言できます。
+マクロは React の JSX のような動きをしますが、JavaScript の代わりに Rust の式を用います。
+Yew は Svelte のように、`onclick={onclick}` の代わりに `{onclick}` と書くことができる省略構文を提供しています。
 
 ```rust
 use yew::{Component, Context, html, Html, Properties};
@@ -88,15 +84,14 @@ impl Component for MyComponent {
 }
 ```
 
-For usage details, check out [the `html!` guide](concepts/html/introduction.mdx).
+使い方については[`html!`ガイド](concepts/html/introduction.mdx)をご確認ください。
 
 ### Rendered
 
-The `rendered` component lifecycle method is called once `view` has been called and Yew has rendered
-the results to the DOM, but before the browser refreshes the page. This method is useful when you
-want to perform actions that can only be completed after the component has rendered elements. There
-is also a parameter called `first_render` which can be used to determine whether this function is
-being called on the first render, or instead a subsequent one.
+`rendered()`コンポーネントのライフサイクルのメソッドは`view()`が処理されて Yew がコンポーネントをレンダリングした後、
+ブラウザがページを更新する前に呼ばれます。
+コンポーネントは、コンポーネントが要素をレンダリングした後にのみ実行できるアクションを実行するため、このメソッドを実装したい場合があります。
+コンポーネントが初めてレンダリングされたかどうかは `first_render` パラメータで確認できます。
 
 ```rust
 use web_sys::HtmlInputElement;
@@ -137,17 +132,17 @@ impl Component for MyComponent {
 ```
 
 :::tip note
-Note that this lifecycle method does not require implementation and will do nothing by default.
+ライフサイクルメソッドは実装の必要がなく、デフォルトでは何もしません。
 :::
 
 ### Update
 
-Communication with components happens primarily through messages which are handled by the
-`update` lifecycle method. This allows the component to update itself
-based on what the message was, and determine if it needs to re-render itself. Messages can be sent
-by event listeners, child components, Agents, Services, or Futures.
+コンポーネントは動的で、非同期メッセージを受信するために登録することができます。
+ライフサイクルメソッド `update()` はメッセージごとに呼び出されます。
+これにより、コンポーネントはメッセージが何であったかに基づいて自身を更新し、自身を再レンダリングする必要があるかどうかを判断することができます。
+メッセージは、HTML 要素リスナーによってトリガーされたり、子コンポーネント、エージェント、サービス、または Futures によって送信されたりします。
 
-Here is an example of what an implementation of `update` could look like:
+`update()`がどのようなのかについての例は以下の通りです:
 
 ```rust
 use yew::{Component, Context, html, Html};
@@ -199,10 +194,10 @@ impl Component for MyComponent {
 
 ### Changed
 
-Components may be re-rendered by their parents. When this happens, they could receive new properties
-and need to re-render. This design facilitates parent-to-child component communication by just
-changing the values of a property. There is a default implementation that re-renders the component
-when props are changed.
+コンポーネントは親によって再レンダリングされることがあります。
+このような場合、新しいプロパティを受け取り、再レンダリングを選択する可能性があります。
+この設計では、プロパティを変更することで、親から子へのコンポーネントの通信が容易になります。
+props が変更されたときにコンポーネントを再レンダリングするデフォルト実装があります。
 
 ### Destroy
 

website/i18n/ja/docusaurus-plugin-content-docs/version-0.21/advanced-topics/struct-components/properties.mdx

@@ -3,21 +3,20 @@ title: 'Properties'
 description: 'Parent to child communication'
 ---
 
-Properties enable child and parent components to communicate with each other.
-Every component has an associated properties type which describes what is passed down from the parent.
-In theory, this can be any type that implements the `Properties` trait, but in practice, there is no
-reason for it to be anything but a struct where each field represents a property.
+プロパティは、子コンポーネントと親コンポーネントが互いに通信できるようにします。
+各コンポーネントには、親から渡されるものを記述する関連付けられたプロパティタイプがあります。
+理論的には、これは `Properties` trait を実装する任意のタイプにすることができますが、実際には
+各フィールドがプロパティを表す構造体以外にする理由はありません。
 
-## Derive macro
+## マクロの継承
 
-Instead of implementing the `Properties` trait yourself, you should use `#[derive(Properties)]` to
-automatically generate the implementation instead.
-Types for which you derive `Properties` must also implement `PartialEq`.
+`Properties`を自分で実装しようとせず、代わりに`#[derive(Properties)]`を使ってください。
+`Properties`を継承した型は`PartialEq`も実装していなければいけません。
 
-### Field attributes
+### フィールド属性
 
-When deriving `Properties`, all fields are required by default.
-The following attributes allow you to give your props initial values which will be used unless they are set to another value.
+デフォルトでは、`Properties` を導出する構造体内のフィールドは必須です。
+以下の属性を使うと、props に初期値を与えることができ、他の値に設定されない限りこの値が使用されます。
 
 :::tip
 Attributes aren't visible in Rustdoc generated documentation.
@@ -39,13 +38,16 @@ Call `function` to initialize the prop value. `function` should have the signatu
 
 ## `PartialEq`
 
-`Properties` require `PartialEq` to be implemented. This is so that they can be compared by Yew to call the `changed` method
-only when they change.
+もし可能なら props で `PartialEq` を継承するのが良いかもしれません。
+`PartialEq`を使うことで、不必要な再レンダリングを避けることができます
+(これについては、**最適化とベストプラクティス**のセクションで説明しています)。
 
-## Memory/speed overhead of using Properties
+## プロパティを使用する際のメモリと速度のオーバーヘッド
 
-Internally properties are reference counted. This means that only a pointer is passed down the component tree for props.
-It saves us from the cost of having to clone the entire props, which might be expensive.
+`Component::view`ではコンポーネントの状態への参照を取り、それを使って `Html` を作成します。
+しかし、プロパティは自身の値です。
+つまり、それらを作成して子コンポーネントに渡すためには、`view` 関数で提供される参照を所有する必要があるのです。
+これは所有する値を取得するためにコンポーネントに渡される参照を暗黙のうちにクローンすることで行われます。
 
 :::tip
 Make use of `AttrValue` which is our custom type for attribute values instead of defining them as String or another similar type.

website/i18n/ja/docusaurus-plugin-content-docs/version-0.21/advanced-topics/struct-components/refs.mdx

@@ -1,17 +1,16 @@
 ---
-title: 'Refs'
-description: 'Out-of-band DOM access'
+title: Refs
+description: Out-of-band DOM access
 ---
 
-The `ref` keyword can be used inside of any HTML element or component to get the DOM `Element` that
-the item is attached to. This can be used to make changes to the DOM outside of the `view` lifecycle
-method.
+`ref`は、任意の HTML 要素やコンポーネントの内部で、割り当てられている DOM`Element`を取得するために使用することができます。
+これは、`view` ライフサイクルメソッドの外で DOM に変更を加えるために使用できます。
 
-This is useful for getting ahold of canvas elements, or scrolling to different sections of a page.
+これは、キャンバスの要素を取得したり、ページの異なるセクションにスクロールしたりするのに便利です。
 For example, using a `NodeRef` in a component's `rendered` method allows you to make draw calls to
 a canvas element after it has been rendered from `view`.
 
-The syntax is:
+構文は以下の通りです:
 
 ```rust
 use web_sys::Element;

website/i18n/zh-Hans/docusaurus-plugin-content-docs/version-0.21/advanced-topics/how-it-works.mdx

@@ -1,9 +1,9 @@
 ---
 title: 'How it works'
-description: 'Low level details about the framework'
+description: '有关框架的底层细节'
 ---
 
-# Low-level library internals
+# 底层库的内部细节
 
 ## Under the hood of the `html!` macro
 

website/i18n/zh-Hans/docusaurus-plugin-content-docs/version-0.21/advanced-topics/optimizations.mdx

@@ -1,7 +1,7 @@
 ---
-title: 'Optimizations & Best Practices'
+title: '性能优化与最佳实践'
 sidebar_label: Optimizations
-description: 'Make your app faster'
+description: 加速你的应用程序
 ---
 
 ## Using smart pointers effectively

website/i18n/zh-Hans/docusaurus-plugin-content-docs/version-0.21/advanced-topics/struct-components/callbacks.mdx

@@ -1,13 +1,13 @@
 ---
-title: 'Callbacks'
+title: '回调（Callbacks）'
+description: 'ComponentLink 和 Callbacks'
 ---
 
 ## Callbacks
 
-Callbacks are used to communicate with services, agents, and parent components within Yew.
-Internally their type is just `Fn` wrapped in `Rc` to allow them to be cloned.
+Callbacks 用于与 Yew 中的 services，agents 和父组件进行通信。它们仅仅是个 `Fn`，并由 `Rc` 包裹以允许被克隆。
 
-They have an `emit` function that takes their `<IN>` type as an argument and converts that to a message expected by its destination. If a callback from a parent is provided in props to a child component, the child can call `emit` on the callback in its `update` lifecycle hook to send a message back to its parent. Closures or Functions provided as props inside the `html!` macro are automatically converted to Callbacks.
+它们有一个 `emit` 函数，该函数将它的 `<IN>` 类型作为参数并将其转换为目标所期望的消息。如果一个回调从父组件中通过 props 提供给子组件，则子组件可以在其 `update` 生命周期钩子中对该回调调用 `emit`，以将消息发送回父组件。在 `html!` 宏内被提供作为 props 的闭包或函数会自动转换为 Callbacks。
 
 A simple use of a callback might look something like this: