在Go语言中，检查文件是否存在有几种方法，但最常见和简单的方法是使用`os.Stat`函数和`os.IsNotExist`函数。下面是一个示例，展示了如何使用这两个函数来检查文件是否存在：

```go
package main

import (
    "fmt"
    "os"
)

// fileExists 检查文件是否存在，返回布尔值和可能出现的错误
func fileExists(filename string) (bool, error) {
    // 使用os.Stat获取文件信息
    info, err := os.Stat(filename)

    if os.IsNotExist(err) {
        // 如果返回的错误类型为文件不存在，则说明文件确实不存在
        return false, nil
    }

    // 如果info不为空，并且没有错误，则文件存在
    return !info.IsDir(), err
}

func main() {
    // 检查文件"example.txt"是否存在
    exists, err := fileExists("example.txt")
    if err != nil {
        // 如果有错误，打印错误并退出
        fmt.Printf("Failed to check if file exists: %v\n", err)
        return
    }

    // 根据存在标志打印相应的信息
    if exists {
        fmt.Println("File exists.")
    } else {
        fmt.Println("File does not exist.")
    }
}
```
在上述代码中，`fileExists`函数会尝试获取指定文件的信息。如果`os.Stat`函数返回一个错误，并且通过`os.IsNotExist`检查确认这个错误是因为文件不存在，则`fileExists`会返回`false`和一个`nil`错误。如果没有错误，并且`info.IsDir()`也为`false`（意味着路径不是一个目录），则函数返回`true`。

需要注意的是，文件可能因为其他原因而无法访问（例如权限问题），此时`os.Stat`会返回非`nil`的错误，这种情况下，你可能需要根据具体的错误类型来作出不同的处理。

检查文件是否不存在，相当于Python的`if not os.path.exists(filename)`：

    if _, err := os.Stat("/path/to/whatever"); errors.Is(err, os.ErrNotExist) {
      // path/to/whatever does not exist
    }
    

检查文件是否存在，相当于Python的`if os.path.exists(filename)`：

编辑：根据最近的评论

    if _, err := os.Stat("/path/to/whatever"); err == nil {
      // path/to/whatever exists
    
    } else if errors.Is(err, os.ErrNotExist) {
      // path/to/whatever does *not* exist
    
    } else {
      // Schrodinger: file may or may not exist. See err for details.
    
      // Therefore, do *NOT* use !os.IsNotExist(err) to test for file existence
    
    
    }

**Caleb Spare**的回答发布在[gonuts](https://groups.google.com/forum/#!msg/golang-nuts/Ayx-BMNdMFo/4rL8FFHr8v4J)邮件列表中。

> \[...\] 实际上并不经常需要它，并且 \[...\]`os.Stat`对于需要它的情况来说使用起来很容易。
> 
> \[...\] 例如：如果您要打开文件，则没有理由先检查它是否存在。该文件可能会在检查和打开之间消失，无论如何您都需要检查错误`os.Open`。因此，您只需在尝试打开文件后调用`os.IsNotExist(err)`，并处理该文件不存在的情况（如果需要特殊处理）。
> 
> \[...\] 您根本不需要检查是否存在路径（而且您也不应该这样做）。
> 
> *   `os.MkdirAll`无论路径是否存在都有效。（您还需要检查该调用的错误。）
>     
> *   `os.Create`您应该使用而不是使用`os.OpenFile(path, os.O_RDWR|os.O_CREATE|os.O_EXCL, 0666)`。这样，如果文件已经存在，您将收到错误消息。此外，这与创建文件的其他内容不存在竞争条件，这与您事先检查是否存在的版本不同。
>     

摘自： https: [//groups.google.com/forum/#! msg/golang-nuts/Ayx-BMNdMFo/4rL8FFHr8v4J](https://groups.google.com/forum/#!msg/golang-nuts/Ayx-BMNdMFo/4rL8FFHr8v4J)

首先要考虑的是，您很少只想检查文件是否存在。在大多数情况下，您会尝试对文件（如果存在）执行某些操作。在 Go 中，任何时候你尝试对不存在的文件执行某些操作，结果都应该是一个特定的错误 ( `os.ErrNotExist`)，最好的办法是检查返回`err`值（例如，当调用类似 的函数时`os.OpenFile(...)`）是否为`os.ErrNotExist`。

**过去**推荐的方法是：

    file, err := os.OpenFile(...)
    if os.IsNotExist(err) {
        // handle the case where the file doesn't exist
    }
    

然而，自从**Go 1.13**（2019 年底发布）中**添加了，`errors.Is`**[新的建议是使用`errors.Is`](https://github.com/golang/go/blob/5ff7ec98b7727b3641df25200345b1aa50b6ff35/src/os/error.go#L90-L91)：

    file, err := os.OpenFile(...)
    if errors.Is(err, os.ErrNotExist) {
        // handle the case where the file doesn't exist
    }
    

* * *

**通常最好避免`os.Stat`在尝试对文件执行某些操作之前使用它来检查文件是否存在，因为在执行某些操作之前，文件总是有可能在一段时间内被重命名、删除等。它。**

然而，如果你同意这个警告，并且你真的只是想检查一个文件是否存在，然后不继续用它做一些有用的事情（作为一个人为的例子，假设你正在编写一个毫无意义的 CLI 工具，告诉你文件是否存在然后退出`¯\_(ツ)_/¯`），那么推荐的方法是：

    if _, err := os.Stat(filename); errors.Is(err, os.ErrNotExist) {
        // file does not exist
    } else {
        // file exists
    }

您应该使用`os.Stat()`和`os.IsNotExist()`函数，如下例所示：

    func Exists(name string) (bool, error) {
        _, err := os.Stat(name)
        if err == nil {
            return true, nil
        }
        if errors.Is(err, os.ErrNotExist) {
            return false, nil
        }
        return false, err
    }
    

edit1：修复了在某些情况下返回 true 的问题。  
edit2：从os.IsNotExist()切换到使用errors.Is()，许多人说这是[最佳实践](https://github.com/golang/go/issues/38198)，在[这里](https://stefanxo.com/go-anti-patterns-os-isexisterr-os-isnotexisterr/)

其他答案错过的是，给函数的路径实际上可能是一个目录。以下函数可确保该路径确实是一个文件。

    func fileExists(filename string) bool {
        info, err := os.Stat(filename)
        if os.IsNotExist(err) {
            return false
        }
        return !info.IsDir()
    }
    
    

另一件需要指出的事情是：此代码仍然可能导致竞争条件，即在 fileExists 函数运行时另一个线程或进程删除或创建指定的文件。

如果您担心这一点，请在线程中使用锁，序列化对此函数的访问，或者在涉及多个应用程序时使用进程间信号量。如果涉及到超出您控制范围的其他应用程序，我想您就不走运了。

How to check if a file exists in go

在Vue中，如果想要通过`watch`监听Vuex中存储的值，你可以使用计算属性(computed properties)结合侦听器(watchers)来实现。Vuex的状态变化是响应式的，这意味着你可以简单地在计算属性中返回Vuex的状态，并在`watch`选项中侦听这个计算属性的变化。

以下是一个具体的例子：

假设你有一个Vuex store，里面存有一个状态叫做`count`。

```javascript
const store = new Vuex.Store({
  state: {
    count: 0
  },
  mutations: {
    increment(state) {
      state.count++;
    }
  }
});
```

你想要在Vue组件中监听`count`值的变化。你可以这样做：

```javascript
new Vue({
  el: '#app',
  store,
  computed: {
    // 使用计算属性来获取Vuex里的状态
    count() {
      return this.$store.state.count;
    }
  },
  watch: {
    // 使用侦听器来监听计算属性的变化
    count(newVal, oldVal) {
      console.log(`count值从${oldVal}变化到${newVal}`);
      // 这里可以根据count值的变化执行一些操作
    }
  }
});
```

在这个例子中，计算属性`count`用来从Vuex获取当前的`count`状态。然后，我们在组件的`watch`选项中定义了一个`count`侦听器，该侦听器将会在计算属性`count`的值变化时触发。这样，每当通过Vuex的mutation改变`count`状态时，计算属性会自动更新，进而触发侦听器中的回调函数。

此外，如果你想要深度监听一个对象的属性变化，可以在`watch`选项中设置`deep: true`，但对于大多数监听单一值的场景，如上述的`count`，这是不必要的。

举例来说，您有一篮子水果，每次从篮子中添加或删除水果时，您希望 (1) 显示有关水果数量的信息，**但**您还 (2) 希望收到以下通知以某种奇特的方式计算水果的数量......

_水果计数组件.vue_

    <template>
      
      
      <p>Fruits: {{ count }}</p>
    </template>
    
    <script>
    import basket from '../resources/fruit-basket'
    
    export default () {
      computed: {
        count () {
          return basket.state.fruits.length
          // Or return basket.getters.fruitsCount
          // (depends on your design decisions).
        }
      },
      watch: {
        count (newCount, oldCount) {
          // Our fancy notification (2).
          console.log(`We have ${newCount} fruits now, yay!`)
        }
      }
    }
    </script>
    

请注意，对象中函数的名称`watch`必须与对象中函数的名称匹配`computed`。在上面的示例中，名称是`count`。

监视属性的新值和旧值将作为参数传递给监视回调（计数函数）。

篮子店可能看起来像这样：

_水果篮.js_

    import Vue from 'vue'
    import Vuex from 'vuex'
    
    Vue.use(Vuex)
    
    const basket = new Vuex.Store({
      state: {
        fruits: []
      },
      getters: {
        fruitsCount (state) {
          return state.fruits.length
        }
      }
      // Obviously you would need some mutations and actions,
      // but to make example cleaner I'll skip this part.
    })
    
    export default basket
    

您可以在以下资源中阅读更多内容：

*   [计算属性和观察者](https://v2.vuejs.org/v2/guide/computed.html)
*   [API 文档：计算的](https://v2.vuejs.org/v2/api/#computed)
*   [API 文档：观看](https://v2.vuejs.org/v2/api/#watch)

很简单：

    watch: {
      '$store.state.drawer': function() {
        console.log(this.$store.state.drawer)
      }
    }
    

如果商店位于模块中，请使用：

    '$store.state.myModule.drawer'
    

对于嵌套文件，请使用：

    '$store.state.fileOne.fileTwo.myModule.drawer'

您不应该使用组件的观察者来监听状态更改。我建议您使用 getters 函数，然后将它们映射到您的组件中。

    import { mapGetters } from 'vuex'
    
    export default {
      computed: {
        ...mapGetters({
          myState: 'getMyState'
        })
      }
    }
    

在您的商店中：

    const getters = {
      getMyState: state => state.my_state
    }
    

您应该能够通过`this.myState`在组件中使用来监听对商店所做的任何更改。

[https://vuex.vuejs.org/en/getters.html#the-mapgetters-helper](https://vuex.vuejs.org/en/getters.html#the-mapgetters-helper)

**如上所述，直接在商店中查看变化并不是一个好主意**

_但在一些非常罕见的情况下，它可能对某人有用，所以我会留下这个答案。其他情况请参阅@gabriel-robert 的回答_

您可以通过`state.$watch`. 将其添加到`created`组件中的（或需要执行此操作的位置）方法中

    this.$store.watch(
        function (state) {
            return state.my_state;
        },
        function () {
            //do something on data change
        },
        {
            deep: true //add this if u need to watch object properties change etc.
        }
    );
    

更多详细信息： https: [//vuex.vuejs.org/api/#watch](https://vuex.vuejs.org/api/#watch)

我认为提问者想将 watch 与 Vuex 一起使用。

    this.$store.watch(
          (state)=>{
            return this.$store.getters.your_getter
          },
          (val)=>{
           //something changed do something
    
          },
          {
            deep:true
          }
          );

How to watch store values from vuex

在Vue.js中，实现页面重定向通常涉及使用Vue Router，它是Vue.js的官方路由管理器。Vue Router允许你定义页面路由、导航、嵌套路由等。下面是几种在Vue应用中实现页面重定向的方法：

### 1. 在路由配置中使用 `redirect`

在Vue Router的路由配置中，你可以指定一个路由规则以`redirect`字段来重定向到另一个路由。

```javascript
const router = new VueRouter({
  routes: [
    { path: '/a', redirect: '/b' }
    // 当用户访问/a时，页面会重定向到/b
  ]
})
```

### 2. 在组件内使用编程式导航

你可以在Vue组件的方法中使用路由实例的`push`或`replace`方法来实现页面导航。

```javascript
this.$router.push('/target-page'); // 将用户导航到目标页面，相当于点了一个链接
// 或者
this.$router.replace('/target-page'); // 替换当前的历史记录条目
```

### 3. 使用导航守卫进行重定向

Vue Router提供了全局和路由独享的导航守卫，你可以在这些守卫中进行重定向。

```javascript
router.beforeEach((to, from, next) => {
  if (to.path === '/a') {
    next('/b'); // 如果用户要访问/a，那么重定向到/b
  } else {
    next(); // 否则，正常导航
  }
});
```

### 4. 使用`<router-link>`进行声明式导航

虽然`<router-link>`主要是用于声明式导航的，也可以用来触发重定向。

```html
<router-link to="/target-page">Go to Target Page</router-link>
```

设置了重定向的路由规则后，点击这个链接将会让应用导航到`/target-page`。

### 示例

假设你有一个登录页面，用户登录成功后需要重定向到首页。你可以在登录方法中使用编程式导航来实现：

```javascript
// Login.vue
export default {
  methods: {
    login() {
      // 登录逻辑...
      if (/* 登录成功 */) {
        this.$router.push('/home'); // 重定向到首页
      }
    }
  }
}
```

重定向是单页应用中常用的功能，Vue Router 提供了灵活的方式来实现不同场景下的页面跳转。在实际应用中，你可能需要结合实际的业务逻辑来选择最合适的重定向方式。

如果您使用的是[Vue Router](https://router.vuejs.org/)，则可以用于`router.push(path)`以编程方式导航到任何特定路线（请注意，这是`router.go(path)`Vue 2 之前的版本）。

`$router`可以从Vue 实例上的属性访问路由器本身，这意味着您可以`push`使用`this.$router.push(path)`.

您还可以使用对象语法进行更多控制，包括导航到预配置的[命名路由](https://router.vuejs.org/guide/essentials/named-routes.html)。从[文档](https://router.vuejs.org/guide/essentials/navigation.html#navigate-to-a-different-location)中：

>     // object
>     router.push({ path: 'home' })
>     
>     // named route
>     router.push({ name: 'user', params: { userId: '123' } })
>     
>     // with query, resulting in /register?plan=private
>     router.push({ path: 'register', query: { plan: 'private' } })
>     
>     // with hash, resulting in /about#team
>     router.push({ path: '/about', hash: '#team' })
>     

除了 Vue 路由器之外，`window.location.href = 'some url';`它也适用于非单页应用程序。

* * *

如果您正在寻找更永久的_重定向_，而不仅仅是编程导航，例如将所有`example.com/foo`点击重定向到`example.com/bar`，那么您应该使用[Vue Router 的重定向或别名功能](https://router.vuejs.org/guide/essentials/redirect-and-alias.html)。

### 重定向

[重定向](https://router.vuejs.org/guide/essentials/redirect-and-alias.html#redirect)位于路由配置中，让你告诉 Vue Router 始终将给定路径重定向到其他地方，例如导航到`/foo`会将你弹回`/bar`：

    const routes = [{ path: '/foo', redirect: '/bar' }];
    

这些路径也可以是动态的，例如：

    const routes = [{ path: '/foo/:subPath*', redirect: '/bar/:subPath*' }];
    // example.com/foo/profile?id=123 --> example.com/bar/profile?id=123
    

### 别名

[别名](https://router.vuejs.org/guide/essentials/redirect-and-alias.html#alias)就像重定向一样，将流量从一个位置路由到另一个位置，**但它们不会更改用户的 URL**。这允许您将 UI 结构的任意部分映射到您想要的任何路径，从而提供更大的灵活性。

从文档中：

>     const routes = [
>       {
>         path: '/users',
>         component: UsersLayout,
>         children: [
>           // this will render the UserList component for these 3 URLs:
>           // - /users
>           // - /users/list
>           // - /people
>           { path: '', component: UserList, alias: ['/people', 'list'] },
>         ],
>       },
>     ]
>

根据文档，router.push 似乎是首选方法：

> 要导航到不同的 URL，请使用 router.push。此方法将新条目推送到历史堆栈中，因此当用户单击浏览器后退按钮时，他们将被带到上一个 URL。

来源： https: [//router.vuejs.org/en/essentials/navigation.html](https://router.vuejs.org/en/essentials/navigation.html)

仅供参考：Webpack 和组件设置，单页应用程序（通过 Main.js 导入路由器），我必须通过以下方式调用路由器函数：

    this.$router
    

示例：如果您想在满足条件后重定向到名为“Home”的路线：

    this.$router.push('Home')

当在组件脚本标签内时，您可以使用路由器并执行类似的操作

    this.$router.push('/url-path')

如果你想路由到另一个页面使用这个

    this.$router.push({path: '/pagename'});
    

如果你想使用参数路由到另一个页面，请使用这个

    this.$router.push({
      path: '/pagename', 
      params: {
        param1: 'value1', 
        param2: 'value2'
      }
    });

How to achieve redirection to another page in vue. Js

在 Vue.js 中，`v-on` 指令用于监听 DOM 事件，例如用户的点击事件。当您在原生 HTML 元素上使用 `v-on:click` 或者是缩写形式 `@click`，它会正常工作，因为这会在该元素上绑定一个点击事件监听器。但是，当您将同样的指令用在一个 Vue 组件上时，情况就有所不同。

组件上的 `v-on` 监听器并不是直接监听子组件根元素的原生事件，而是监听由子组件触发的自定义事件。Vue 组件实例不会自动将它们的事件监听器作为原生 DOM 事件处理程序。这是因为组件的根元素可以是任何元素或者其他组件，Vue 不会对它做特殊处理。

如果你要在组件上监听一个原生事件（比如点击事件），你需要使用 `.native` 修饰符，指示 `v-on` 监听原生事件，如下所示：

```vue

<template>
  <button @click="$emit('click')">Click me</button>
</template>
<script>
export default {
  emits: ['click']
};
</script>
```

```vue

<template>
  <my-component @click.native="handleClick"></my-component>
</template>
<script>
export default {
  methods: {
    handleClick() {
      console.log('Button clicked!');
    }
  }
};
</script>
```

在这个例子中，我们有一个子组件 `MyComponent`，它在一个按钮上监听点击事件，并在点击时触发一个名为 `click` 的自定义事件。在父组件中，我们使用 `.native` 修饰符来监听这个原生的点击事件。但是要注意的是，从 Vue 3 开始，`.native` 修饰符已被移除，因为 Vue 3 提倡组件应该显式地定义和触发它们自己的自定义事件。

因此，在 Vue 3 中，您应该在子组件中通过 `$emit` 来显式地发出自定义事件，并在父组件中监听这些事件而不是原生事件。如果你确实需要在父组件中监听子组件根元素的原生事件，你应该在子组件内部绑定一个原生事件监听器，并在需要时触发一个自定义事件。

如果你想监听组件根元素上的原生事件，你必须使用[.native](https://v2.vuejs.org/v2/guide/components.html#Using-v-on-with-Custom-Events)修饰符`v-on`，如下所示：

    <template>
      <div id="app">
        <test v-on:click.native="testFunction"></test>
      </div>
    </template>
    

或者简而言之，正如评论中所建议的，您也可以这样做：

    <template>
      <div id="app">
        <test @click.native="testFunction"></test>
      </div>
    </template>
    

[参考阅读有关**本机事件的更多信息**](https://v2.vuejs.org/v2/guide/migration.html#Listening-for-Native-Events-on-Components-with-v-on-changed)

我认为该`$emit`功能更适合您的要求。它将您的组件与 Vue 实例分开，以便它可以在许多上下文中重用。

    
    <template>
      <div id="app">
        <test @click="$emit('test-click')"></test>
      </div>
    </template>
    

在 HTML 中使用它：

    
    <test @test-click="testFunction">

这是[@Neps 的答案](https://stackoverflow.com/a/50995368/10895487)，但有详细信息。

* * *

**注意**：如果您不想修改组件或无权访问它，[@Saurabh 的答案更合适。](https://stackoverflow.com/a/41476882/10895487)

* * *

为什么@click 不能正常工作？
=================

组件很复杂。一个组件可以是一个小型的精美按钮包装器，另一个组件可以是内部有一堆逻辑的整个表格。Vue 不知道绑定`v-model`或使用时您到底期望什么`v-on`，因此所有这些都应该由组件的创建者处理。

如何处理点击事件
========

根据[Vue 文档](https://v2.vuejs.org/v2/guide/components.html#Sending-Messages-to-Parents-with-Events)，`$emit`将事件传递给父级。文档中的示例：

**主文件**

    <blog-post
      @enlarge-text="onEnlargeText"
    />
    

**成分**

    <button @click="$emit('enlarge-text')">
      Enlarge text
    </button>
    

（`@`是`v-on` [简写](https://v2.vuejs.org/v2/guide/syntax.html#v-on-Shorthand)）

组件处理本机`click`事件并发出父级事件`@enlarge-text="..."`

`enlarge-text`可以替换为`click`使其看起来像我们正在处理本机点击事件：

    <blog-post @click="onEnlargeText">
      Enlarge text
    </blog-post>
    
    
    <button @click="$emit('click')">
      Enlarge text
    </button>
    

但这还不是全部。`$emit`允许通过事件传递特定值。在native的情况下`click`，值为[MouseEvent](https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent)（与Vue无关的JS事件）。

Vue 将该事件存储在`$event`变量中。因此，最好`$event`与事件一起发出，以营造本机事件使用的印象：

    <button v-on:click="$emit('click', $event)">
      Enlarge text
    </button>

正如 Chris Fritz（Vue.js[核心团队荣誉退休人员](https://v2.vuejs.org/v2/guide/team.html)）在[VueCONF US 2019中提到的](https://www.youtube.com/watch?v=b554XmaTWrw&t=646)

> 如果我们让 Kia 输入`.native`，然后基本输入的根元素从输入更改为标签，突然该组件被破坏并且不明显，事实上，除非您有一个非常好的测试，否则您甚至可能无法立即捕获它。相反，通过避免使用**我目前认为是反模式并将在 Vue 3 中删除的**`.native`修饰符，您将能够显式定义父级可能关心添加到哪些元素侦听器...

使用 Vue 2
========

使用`$listeners`：
---------------

因此，如果您使用 Vue 2，解决此问题的更好选择是使用**完全透明的包装器**逻辑。为此，Vue 提供了一个`$listeners`属性，其中包含组件上使用的侦听器对象。例如：

    {
      focus: function (event) { /* ... */ }
      input: function (value) { /* ... */ },
    }
    

然后我们只需要添加`v-on="$listeners"`到组件中`test`，例如：

**Test.vue（子组件）**

    <template>
      <div v-on="$listeners">
        click here
      </div>
    </template>
    

现在该`<test>`组件是一个**完全透明的包装器**，这意味着它可以像普通元素一样使用`<div>`：所有侦听器都可以工作，无需`.native`修饰符。

**演示：**

    Vue.component('test', {
      template: `
        <div class="child" v-on="$listeners">
          Click here
        </div>`
    })
    
    new Vue({
      el: "#myApp",
      data: {},
      methods: {
        testFunction: function(event) {
          console.log('test clicked')
        }
      }
    })

    div.child{border:5px dotted orange; padding:20px;}

    <script src="https://cdnjs.cloudflare.com/ajax/libs/vue/2.5.17/vue.min.js"></script>
    <div id="myApp">
      <test @click="testFunction"></test>
    </div>

运行代码片段Hide results

展开片段

使用[`$emit`](https://v2.vuejs.org/v2/api/#vm-emit)方法：
----------------------------------------------------

我们也可以使用该`$emit`方法来实现此目的，这有助于我们在父组件中监听子组件的事件。为此，我们首先需要从子组件发出[自定义事件，例如：](https://v2.vuejs.org/v2/guide/components-custom-events.html#ad)

**Test.vue（子组件）**

    <test @click="$emit('my-event')"></test>
    

**重要提示：**始终使用短横线命名的事件名称。有关这一点的更多信息和演示，请查看此答案：[VueJS将计算值从组件传递到父级](https://stackoverflow.com/a/61693165/1823841)。

现在，我们只需要在父组件中监听这个发出的自定义事件，例如：

**应用程序.vue**

    <test @my-event="testFunction"></test>
    

所以基本上，我们将简单地使用or 来代替or 的`v-on:click`简写。`@click``v-on:my-event``@my-event`

**演示：**

    Vue.component('test', {
      template: `
        <div class="child" @click="$emit('my-event')">
          Click here
        </div>`
    })
    
    new Vue({
      el: "#myApp",
      data: {},
      methods: {
        testFunction: function(event) {
          console.log('test clicked')
        }
      }
    })

    div.child{border:5px dotted orange; padding:20px;}

    <script src="https://cdnjs.cloudflare.com/ajax/libs/vue/2.5.17/vue.min.js"></script>
    <div id="myApp">
      <test @my-event="testFunction"></test>
    </div>

运行代码片段Hide results

展开片段

* * *

使用 Vue 3
========

使用`v-bind="$attrs"`：
--------------------

Vue 3 将从很多方面让我们的生活变得更加轻松。一个例子是，它将帮助我们创建一个**更简单的透明包装器**，配置更少，只需使用`v-bind="$attrs"`. 通过在子组件上使用它，我们的侦听器不仅可以直接从父组件工作，而且任何其他属性也将像普通的`<div>`.

因此，对于这个问题，我们不需要更新 Vue 3 中的任何内容，您的代码仍然可以正常工作，就像`<div>`这里的根元素一样，它将自动侦听所有子事件。

**演示#1：**

    const { createApp } = Vue;
    
    const Test = {
      template: `
        <div class="child">
          Click here
        </div>`
    };
    
    const App = {
      components: { Test },
      setup() {
        const testFunction = event => {
          console.log("test clicked");
        };
        return { testFunction };
      }
    };
    
    createApp(App).mount("#myApp");

    div.child{border:5px dotted orange; padding:20px;}

    <script src="https://cdnjs.cloudflare.com/ajax/libs/vue/3.4.8/vue.global.min.js"></script>
    <div id="myApp">
      <test v-on:click="testFunction"></test>
    </div>

运行代码片段Hide results

展开片段

但是，对于具有嵌套元素的复杂组件，我们需要将属性和事件应用于而`<input />`不是父标签，我们可以简单地使用`v-bind="$attrs"`

**演示#2：**

    const { createApp } = Vue;
    
    const BaseInput = {
      props: ['label', 'value'],
      template: `
        <label>
          {{ label }}
          <input v-bind="$attrs">
        </label>`
    };
    
    const App = {
      components: { BaseInput },
      setup() {
        const search = event => {
          console.clear();
          console.log("Searching...", event.target.value);
        };
        return { search };
      }
    };
    
    createApp(App).mount("#myApp");

    input{padding:8px;}

    <script src="https://cdnjs.cloudflare.com/ajax/libs/vue/3.4.8/vue.global.min.js"></script>
    <div id="myApp">
      <base-input 
        label="Search: "
        placeholder="Search"
        @keyup="search">
      </base-input><br/>
    </div>

运行代码片段Hide results

展开片段

有点冗长，但这就是我的做法：

`@click="$emit('click', $event)"`  
  

**更新：** @sparkyspider 添加的示例

    <div-container @click="doSomething"></div-container>
    

在`div-container`组件...

    <template>
      <div @click="$emit('click', $event);">The inner div</div>
    </template>

Why v- on :click does not work on a vue component?

在Vue组件中将外部JavaScript脚本添加到组件中通常有以下几种方式：

### 1. 使用`<script>`标签在`index.html`中直接引入

在Vue项目的入口文件`index.html`中，可以直接在`<head>`标签或者`<body>`标签的底部添加`<script>`标签来引入外部脚本。

```html

<script src="https://example.com/some-external-script.js"></script>
```

这种方式的好处是全局只加载一次，所有组件都可以访问到该脚本提供的功能，但缺点是不论组件是否需要该脚本，它都会被加载。

### 2. 动态加载使用`import()`

可以在组件内使用JavaScript的动态导入（`import()`），这样可以在需要的时候才加载和解析脚本，还支持模块化的代码。

```javascript
// Vue组件内
export default {
  name: 'MyComponent',
  mounted() {
    import('path-to-external-script')
      .then(module => {
        // 使用加载的脚本
        module.someFunction();
      })
      .catch(err => {
        console.error('Failed to load the external script', err);
      });
  }
};
```

使用动态导入可以更好地控制脚本加载的时机，实现按需加载，优化性能。

### 3. 使用第三方库

有时外部脚本可能是一个第三方库，可以通过npm或yarn这样的包管理器来安装，并在组件中以模块的方式导入。

```bash
npm install some-external-library
# 或者
yarn add some-external-library
```

然后在Vue组件中导入使用：

```javascript
// Vue组件内
import someLibrary from 'some-external-library';

export default {
  name: 'MyComponent',
  mounted() {
    someLibrary.someFunction();
  }
};
```

### 4. 使用Vue插件

如果外部脚本是一个Vue插件，可以在Vue实例创建之前使用`Vue.use()`来注册插件。

```javascript
import Vue from 'vue';
import SomePlugin from 'some-vue-plugin';

Vue.use(SomePlugin);

new Vue({
  // ... 配置项
});
```

注册插件后，通常可以在所有的Vue组件中使用该插件提供的功能。

### 5. 动态创建`<script>`标签

有时，你可能需要在组件的生命周期钩子中动态创建并添加`<script>`标签。

```javascript
export default {
  name: 'MyComponent',
  mounted() {
    const script = document.createElement('script');
    script.src = 'https://example.com/some-external-script.js';
    script.onload = () => {
      // 脚本加载完成后执行的操作
    };
    document.body.appendChild(script);
  }
};
```

这种方法允许你在组件的生命周期内控制脚本的加载，但需要注意清理，防止内存泄露，如在组件销毁时移除创建的script标签。

### 总结

选择哪种方法取决于你的具体需求，如全局可用性、按需加载、依赖管理等。在实际开发中，推荐根据项目的结构和需求来合理安排资源的加载方式。

解决此问题的一个简单有效的方法是将外部脚本添加到`mounted()`组件的 vue 中。我将用[Google Recaptcha](https://www.google.com/recaptcha/intro/)脚本向您说明：

    <template>
       .... your HTML
    </template>
    
    <script>
      export default {
        data: () => ({
          ......data of your component
        }),
        mounted() {
          let recaptchaScript = document.createElement('script')
          recaptchaScript.setAttribute('src', 'https://www.google.com/recaptcha/api.js')
          document.head.appendChild(recaptchaScript)
        },
        methods: {
          ......methods of your component
        }
      }
    </script>
    

来源： https: [//medium.com/@lassiuosukainen/how-to-include-a-script-tag-on-a-vue-component-fe10940af9e8](https://medium.com/@lassiuosukainen/how-to-include-a-script-tag-on-a-vue-component-fe10940af9e8)

我下载了一些带有自定义 js 文件和 jquery 的 HTML 模板。我必须将这些 js 附加到我的应用程序中。并继续使用 Vue。

在这种情况下，这个包非常适合我 [https://www.npmjs.com/package/vue-plugin-load-script](https://www.npmjs.com/package/vue-plugin-load-script)

    // local files
    // you have to put your scripts into the public folder. 
    // that way webpack simply copy these files as it is.
    Vue.loadScript("/js/jquery-2.2.4.min.js")
    
    // cdn
    Vue.loadScript("https://maps.googleapis.com/maps/api/js")

使用 webpack 和 vue loader 你可以做这样的事情

它在创建组件之前等待外部脚本加载，因此 globar vars 等在组件中可用

    components: {
     SomeComponent: () => {
      return new Promise((resolve, reject) => {
       let script = document.createElement('script')
       script.onload = () => {
        resolve(import(someComponent))
       }
       script.async = true
       script.src = 'https://maps.googleapis.com/maps/api/js?key=APIKEY&libraries=places'
       document.head.appendChild(script)
      })
     }
    },

更新：这在 Vue 3 中不再有效。您将收到此错误：

> VueCompilerError：具有副作用（ 和 ）的标签在客户端组件模板中被忽略。

* * *

**如果您尝试将外部 js 脚本嵌入到 vue.js 组件模板中，请按照以下步骤操作：**

我想向我的组件添加**外部 JavaScript 嵌入代码，**如下所示：

    <template>
      <div>
        This is my component
        <script src="https://badge.dimensions.ai/badge.js"></script>
      </div>
    <template>
    

Vue 向我展示了这个错误：

> 模板应该只负责将状态映射到 UI。避免在模板中放置具有副作用的标签，例如 ，因为它们不会被解析。

* * *

**我解决这个问题的方法是添加`type="application/javascript"`**（[请参阅此问题以了解有关 js 的 MIME 类型的更多信息](https://stackoverflow.com/questions/189850/what-is-the-javascript-mime-type-for-the-type-attribute-of-a-script-tag)）：

`<script type="application/javascript" defer src="..."></script>`

* * *

_您可能会注意到该`defer`属性。如果您想了解更多信息，请观看[Kyle 的视频](https://www.youtube.com/watch?v=BMuFBYw91UQ)_

这可以简单地像这样完成。

      created() {
        var scripts = [
          "https://cloudfront.net/js/jquery-3.4.1.min.js",
          "js/local.js"
        ];
        scripts.forEach(script => {
          let tag = document.createElement("script");
          tag.setAttribute("src", script);
          document.head.appendChild(tag);
        });
      }

How to add external js scripts to vuejs components

在 Vue.js 中，computed 计算属性本身是不可以直接接受参数的。计算属性被设计为基于它们的依赖进行缓存的属性，意味着它们只能访问组件的响应式数据，并在这些响应式数据变化时重新计算。由于计算属性在内部是基于它们的依赖进行缓存的，因此它们没有办法接收参数来动态决定如何计算值。

如果你需要类似于传递参数给计算属性的功能，通常有两种替代方案：

1. **方法 (methods)**: 你可以使用一个方法来接收参数并返回计算后的值，而不是使用计算属性。不过，请注意，与计算属性不同，方法不会缓存结果，每次重新渲染时都会执行。

2. **使用方法返回一个函数**: 另一个变通的办法是你可以定义一个方法，该方法返回一个函数，然后这个函数可以作为计算属性那样使用，并接受参数进行计算。虽然这个函数不会被缓存，但是你可以在这个函数内部使用计算属性或其他缓存的值。

这里有一个简单的例子说明如何使用方法返回一个函数来模拟带参数的计算属性：

```vue
<template>
  <div>
    <p>Message with prefix: {{ computedWithParam('Hello, ') }}</p>
  </div>
</template>

<script>
export default {
  data() {
    return {
      message: 'Vue'
    };
  },
  methods: {
    computedWithParam(prefix) {
      // 方法返回一个函数
      return (suffix) => {
        // 这个函数接受参数并返回处理结果
        return prefix + this.message + suffix;
      };
    }
  }
};
</script>
```

在这个例子中，`computedWithParam` 是一个方法，它返回了一个可以接受参数的函数，这个函数可以在模板中被调用，并传递实际的参数进去。

总的来说，尽管计算属性不支持传参，但你可以通过上述方法实现类似的功能。

Can i pass parameters in computed properties in vue js

Vue.js 通常是响应式的，当对应的数据变化时，Vue 会自动更新 DOM。然而，在某些情况下，你可能需要强制 Vue 组件重新渲染，即便其数据没有发生变化。以下是几种可以实现强制重新渲染的方法：

### 1. 使用 `key` 属性

在 Vue 中，你可以通过改变一个组件的 `key` 属性来强制其重新渲染。`key` 属性是 Vue 的一个特殊属性，用于跟踪节点的身份，这可以用于强制重新渲染组件。

```vue
<template>
  <your-component :key="componentKey"></your-component>
</template>

<script>
export default {
  data() {
    return {
      componentKey: 0,
    };
  },
  methods: {
    reloadComponent() {
      this.componentKey += 1;
    }
  }
};
</script>
```

在上述例子中，每当你调用 `reloadComponent` 方法时，`componentKey` 的值都会增加，这将会导致 `your-component` 重新创建和渲染。

### 2. 使用 `v-if` 指令

另一种方法是利用 `v-if` 指令来控制组件的渲染。你可以在一个变量上切换 `v-if` 的值，使组件先销毁，然后再重新创建。

```vue
<template>
  <your-component v-if="isComponentVisible"></your-component>
</template>

<script>
export default {
  data() {
    return {
      isComponentVisible: true,
    };
  },
  methods: {
    reloadComponent() {
      this.isComponentVisible = false;
      this.$nextTick(() => {
        this.isComponentVisible = true;
      });
    }
  }
};
</script>
```

在这个例子中，`reloadComponent` 方法首先将 `isComponentVisible` 设置为 `false`，这会导致组件被销毁。然后，使用 `$nextTick` 方法等待 Vue 完成 DOM 更新，在回调函数中将 `isComponentVisible` 设置回 `true`，重新渲染组件。

### 3. 使用 `forceUpdate`

虽然不是最推荐的方法，因为它违背了 Vue 的响应式原则，但你也可以使用 Vue 实例的 `forceUpdate` 方法来强制更新视图。

```javascript
this.$forceUpdate();
```

这将会导致组件内的所有子组件也会进行重新渲染。需要注意的是，过度使用 `$forceUpdate` 可能会导致性能问题，因为它绕过了 Vue 的响应式系统。

总之，通常建议尽量避免强制重新渲染组件，而是寻找更符合 Vue 响应式原理的解决办法。只有在特定情况下，当其他方法行不通时，才使用上述提到的方法。

试试这个魔法咒语：

    vm.$forceUpdate();
    //or in file components
    this.$forceUpdate();
    

无需创建任何悬挂变量:)

**更新：**当我刚开始使用 VueJS 时，我发现了这个解决方案。然而，进一步的探索证明这种方法是一种拐杖。据我记得，有一段时间我摆脱了它，只是将所有无法自动刷新的属性（主要是嵌套属性）放入计算属性中。

更多信息请参见：[https ://v2.vuejs.org/v2/guide/compulated.html](https://v2.vuejs.org/v2/guide/computed.html)

这似乎是[matthiasg](https://github.com/matthiasg)关于[这个问题](https://github.com/vuejs/Discussion/issues/356)的一个非常干净的解决方案：

> `:key="someVariableUnderYourControl"`当您想要完全重建组件时，您还可以使用和更改密钥

对于我的用例，我将 Vuex getter 作为 prop 提供给组件。Vuex 会以某种方式获取数据，但反应性不会可靠地启动以重新渲染组件。就我而言，将组件设置`key`为 prop 上的某个属性可以保证在 getter（和属性）最终解析时刷新。

请阅读此 [http://michaelnthiessen.com/force-re-render/](http://michaelnthiessen.com/force-re-render/)

> 可怕的方法：重新加载整个页面  
> 可怕的方法：使用 v-if hack  
> 更好的方法：**使用 Vue 的内置 forceUpdate 方法**  
> 最好的方法：**在组件上更改键**  

    <template>
       <component-to-re-render :key="componentKey" />
    </template>
    
    <script>
     export default {
      data() {
        return {
          componentKey: 0,
        };
      },
      methods: {
        forceRerender() {
          this.componentKey += 1;  
        }
      }
     }
    </script>
    

在某些情况下我也使用 watch: 。

尝试使用`this.$router.go(0);`手动重新加载当前页面。

How to  force  reload/ re - render  in Vue. Js

`v-model` 和 `v-bind` 是 Vue 中的两个指令，它们在功能上有所不同：

### `v-model`

`v-model` 是 Vue 的一个指令，用于在表单输入元素和应用状态之间创建双向数据绑定。这意味着，当您在输入框中输入内容时，绑定的数据会自动更新；同样，当更新了绑定的数据时，输入框内的内容也会自动更新。

**用途**：通常用于表单控件如 `<input>`, `<select>`, `<textarea>` 等。

**示例**：

```html
<template>
  <input v-model="message" placeholder="输入一些文字">
  <p>输入的消息是： {{ message }}</p>
</template>

<script>
export default {
  data() {
    return {
      message: ''
    };
  }
};
</script>
```

在这个例子中，`v-model` 将 input 的值和 data 中的 `message` 属性进行了双向绑定。当用户在输入框中键入时，`message` 属性的值会更新；同样，如果通过其他方式更改了 `message` 的值，输入框也会显示最新的内容。

### `v-bind`

`v-bind` 是 Vue 的一个指令，用于单向绑定父组件的数据到子组件的属性上。它通常用来动态设置 HTML 元素的属性或子组件的 prop。

**用途**：在处理任何 HTML 属性或组件 prop 的单向绑定时使用。

**示例**：

```html
<template>
  <div>
    <img v-bind:src="imageSrc" />
  </div>
</template>

<script>
export default {
  data() {
    return {
      imageSrc: 'path/to/image.jpg'
    };
  }
};
</script>
```

在这个例子中，`v-bind` 将 img 标签的 src 属性绑定到 Vue 实例的 data 中的 `imageSrc` 属性上。当 `imageSrc` 的值发生变化时，img 的 src 属性会自动更新以反映这一变化。但这种绑定是单向的，即 img 的变化不会影响到 `imageSrc` 的值。

### 区别总结

- **数据流向**：`v-model` 是双向绑定，而 `v-bind` 是单向绑定。
- **用途**：`v-model` 主要用于表单元素，而 `v-bind` 适用于绑定 HTML 属性和组件的 props。
- **语法简洁性**：`v-model` 直接写在指令上，而 `v-bind` 后通常需要指定具体的属性，例如 `v-bind:src`、`v-bind:class` 等。在简写形式中，`v-bind` 可以直接使用冒号(`:`)，如 `:src="imageSrc"`。

理解这两个指令的不同用途和工作方式对于有效地使用 Vue 来构建交互式界面是非常重要的。

What are the difference between v-model and v-bind in vuejs

在Vue.js中，您可以使用`this.$route.query`来访问URL中的查询参数（也称为查询字符串）。这里`$route`是Vue Router的一个对象，它提供了路由的各种信息，包括当前路由的查询参数。每个查询参数都是`$route.query`对象的一个属性，您可以通过属性名来获取相应的值。

例如，如果URL是这样的：
```
http://example.com/?userId=123&isAdmin=true
```

在您的Vue组件内部，您可以这样获取`userId`和`isAdmin`这两个查询参数：

```javascript
export default {
  mounted() {
    // 获取查询参数
    const userId = this.$route.query.userId;
    const isAdmin = this.$route.query.isAdmin === 'true'; // 转换为布尔值

    console.log(userId); // 输出：123
    console.log(isAdmin); // 输出：true
  }
}
```
这里的`mounted()`是Vue组件的生命周期钩子之一，在组件被挂载到DOM后会被调用，此时是获取查询参数的好时机。

如果您需要在响应查询参数的变化，可以使用Vue的`watch`属性来观察`$route`的变化：

```javascript
export default {
  watch: {
    '$route.query': {
      immediate: true, // 立即以当前值触发回调
      handler(newQuery, oldQuery) {
        // 当查询参数变化时，做一些操作
        console.log('New query params:', newQuery);
      }
    }
  }
}
```

在这个例子中，当URL的查询参数发生变化时，`handler`函数会被调用，并且得到新旧两个查询参数对象。`immediate: true`选项确保了在watcher创建时handler将立即以当前的查询参数值被调用。

请注意，以上例子假设您已经在Vue.js项目中设置了Vue Router。如果没有设置Vue Router，您将无法使用`this.$route`来获取查询参数。

试试这个代码

    var vm = new Vue({
      created() {
        let urlParams = new URLSearchParams(window.location.search);
        console.log(urlParams.has('yourParam')); // true
        console.log(urlParams.get('yourParam')); // "MyParam"
      },
    });

更详细的答案来帮助 VueJS 新手：

*   首先定义您的路由器对象，选择您认为合适的模式。您可以在路由列表中声明您的路由。
*   接下来，您希望主应用程序知道路由器存在，因此在主应用程序声明中声明它。
*   最后，`$route`实例保存有关当前路由的所有信息。该代码将控制台仅记录 url 中传递的参数。（\*Mounted 与 类似`document.ready`，即应用程序准备好后立即调用）

以及代码本身：

    <script src="https://unpkg.com/vue-router"></script>
    var router = new VueRouter({
        mode: 'history',
        routes: []
    });
    var vm =  new Vue({
        router,
        el: '#app',
        mounted: function() {
            q = this.$route.query.q
            console.log(q)
        },
    });

另一种方法（假设您正在使用`vue-router`）是将查询参数映射到路由器中的道具。然后您可以像组件代码中的任何其他 prop 一样对待它。例如添加这条路由；

    { 
      path: '/mypage', 
      name: 'mypage', 
      component: MyPage, 
      props: (route) => ({ foo: route.query.foo }),  
    }
    

然后在你的组件中你可以像平常一样添加道具；

    props: {
      foo: {
        type: String,
        default: null,
      }
    },
    

然后它将可用`this.foo`，您可以用它做任何您想做的事情（例如设置观察者等）

How can i get query parameters from a url in vue js

在RxJS中，将Promise转化为Observable是一个非常常见的操作，可以使用RxJS提供的工具函数来完成。具体来说，你可以使用`from`这个函数来实现这一转换。`from`函数可以将数组、类数组对象、Promise、迭代器等转化为Observable。

下面是一个将Promise转化为Observable的具体例子：

```javascript
import { from } from 'rxjs';

// 假设我们有一个返回Promise的函数
function fetchData() {
  return new Promise(resolve => {
    setTimeout(() => {
      resolve('Data loaded');
    }, 1000);
  });
}

// 使用 from 将 Promise 转化为 Observable
const dataObservable = from(fetchData());

// 订阅 Observable 来处理数据
dataObservable.subscribe({
  next(data) {
    console.log(data); // 输出：Data loaded
  },
  error(err) {
    console.error('Something wrong occurred: ' + err);
  },
  complete() {
    console.log('Done');
  }
});
```

在上面的代码中，`fetchData`函数返回一个将在1秒后解析的Promise。我们通过`from`函数把这个Promise转换成Observable，然后通过`subscribe`方法订阅这个Observable，以便当Promise解析后，我们可以接收到数据并进行处理。

使用`from`函数来转换Promise到Observable的方法非常简单且强大，因为它让Promise可以无缝地融入到RxJS的响应式编程模式中，使得对异步操作的处理更加灵活和强大。

如果您使用的是 RxJS 6.0.0：

    import { from } from 'rxjs';
    const observable = from(promise);

1 直接执行/转换
---------

用于[`from`](https://rxjs-dev.firebaseapp.com/api/index/function/from)直接将先前创建的 Promise 转换为 Observable。

    import { from } from 'rxjs';
    
    // getPromise() is called once, the promise is passed to the Observable
    const observable$ = from(getPromise());
    

`observable$`将成为一个**热门的 Observable**，它可以有效地向订阅者重放 Promise 值。

它是一个热门的 Observable，因为生产者（在本例中为 Promise）是在 Observable 外部创建的。多个订阅者将共享同一个 Promise。如果内部 Promise 已得到解决，Observable 的新订阅者将立即获得其值。

2 每个订阅的延迟执行
-----------

使用[`defer`](https://rxjs-dev.firebaseapp.com/api/index/function/defer)Promise 工厂函数作为输入，以推迟 Promise 到 Observable 的创建和转换。

    import { defer } from 'rxjs';
    
    // getPromise() is called every time someone subscribes to the observable$
    const observable$ = defer(() => getPromise());
    

`observable$`将是一个**冷的 Observable**。

它是一个冷的 Observable，因为生产者（Promise）是在 Observable 内部创建的。每个订阅者将通过调用给定的 Promise 工厂函数来创建一个新的 Promise。

这允许您创建一个 Promise `observable$`，而无需立即创建并执行 Promise，也无需与多个订阅者共享此 Promise。每个用户都可以`observable$`有效地进行呼叫`from(promiseFactory()).subscribe(subscriber)`。因此，每个订阅者创建自己的新 Promise 并将其转换为新的 Observable，并将自己附加到这个新的 Observable。

3 不少运营商直接接受承诺
-------------

大多数组合（例如，，，`merge`... `concat`）或转换可观察值（例如，，，， ...）的RxJS 运算符直接接受 Promise `forkJoin`。如果您无论如何都使用其中之一，则不必首先使用包装承诺（但要创建**冷可观察，**您仍然可能需要使用）。`combineLatest``switchMap``mergeMap``concatMap``catchError``from``defer`

    // Execute two promises simultaneously
    forkJoin(getPromise(1), getPromise(2)).pipe(
      switchMap(([v1, v2]) => v1.getPromise(v2)) // map to nested Promise
    )
    

检查[文档](https://rxjs-dev.firebaseapp.com/api)或[实施](https://github.com/ReactiveX/rxjs/tree/master/src/internal)以查看您使用的运算符是否接受`ObservableInput`或`SubscribableOrPromise`。

    type ObservableInput<T> = SubscribableOrPromise<T> | ArrayLike<T> | Iterable<T>;
    // Note the PromiseLike ----------------------------------------------------v
    type SubscribableOrPromise<T> = Subscribable<T> | Subscribable<never> | PromiseLike<T> | InteropObservable<T>;
    

* * *

**`from`和之间的区别`defer`示例：** [https://stackblitz.com/edit/rxjs-6rb7vf](https://stackblitz.com/edit/rxjs-6rb7vf)

    const getPromise = val => new Promise(resolve => {
      console.log('Promise created for', val);
      setTimeout(() => resolve(`Promise Resolved: ${val}`), 5000);
    });
    
    // the execution of getPromise('FROM') starts here, when you create the promise inside from
    const fromPromise$ = from(getPromise('FROM'));
    const deferPromise$ = defer(() => getPromise('DEFER'));
    
    fromPromise$.subscribe(console.log);
    // the execution of getPromise('DEFER') starts here, when you subscribe to deferPromise$
    deferPromise$.subscribe(console.log);
    

`defer`可能是大多数人正在寻找的运算符，因为许多应用程序都依赖 Observables 来保持冷状态并在订阅时触发数据获取。`from`不过，对于某些用例来说，这仍然是一个可行的选择，例如，当您想在某些初始化过程中创建一次 Promise，然后通过将被订阅多次的 Observable 传播其值，但又不想创建和执行再次向每一位订阅者承诺。

尝试这个：

    import 'rxjs/add/observable/fromPromise';
    import { Observable } from "rxjs/Observable";
    
    const subscription = Observable.fromPromise(
        firebase.auth().createUserWithEmailAndPassword(email, password)
    );
    subscription.subscribe(firebaseUser => /* Do anything with data received */,
                           error => /* Handle error here */);
    

[您可以在此处](http://reactivex.io/rxjs/class/es6/Observable.js~Observable.html#static-method-fromPromise)找到 fromPromise 运算符的完整参考。

将 Promise 转换为 Observable 的正确**模式****`defer`**是使用and**`from`**运算符：

    import { defer, from } from 'rxjs';
        
    const observable$ = defer(() => from(myPromise()));
    

为什么我们需要`defer`运营商？

Promise 是**急切的**，这意味着当被调用时它们会立即触发。这与可观察量的工作方式相反。Observables 是**惰性的**，它们仅在`.subscribe()`被调用时才会被触发。这就是我们需要始终将其包装到运算符中的原因`defer`。操作`from`员不做这项工作，所以`defer`总是需要**的**。

您可以添加一个围绕 Promise 功能的包装器，以将 Observable 返回给观察者。

*   使用**defer()**运算符创建**Lazy** Observable ，它允许您仅在观察者订阅时创建 Observable。

    import { of, Observable, defer } from 'rxjs'; 
    import { map } from 'rxjs/operators';
    
    
    function getTodos$(): Observable<any> {
      return defer(()=>{
        return fetch('https://jsonplaceholder.typicode.com/todos/1')
          .then(response => response.json())
          .then(json => {
            return json;
          })
      });
    }
    
    getTodos$().
     subscribe(
       (next)=>{
         console.log('Data is:', next);
       }
    )

How to convert Promise to Observable

当然，我很乐意回答这个问题。

在RxJS中，`Observable`和`Subject`都是可观察序列的基础构建块，但它们在功能和用法上有一些关键的区别：

### Observable

1. **基本概念**：`Observable`是RxJS提供的一种数据类型，它表示一个可随时间推送值的异步数据流。你可以订阅（subscribe）一个Observable，然后在值到来的时候通过提供的回调函数进行处理。

2. **单向数据流**：`Observable`是单向数据流的，意味着它们可以发射（emit）数据、完成（complete）或者发出错误（error），但是外部是无法直接对Observable发射的数据流进行控制的。

3. **冷Observable**：默认情况下，Observable是冷的（cold），这意味着每一个订阅者都会得到一个独立的数据流。这就是说，Observable在每次有新的订阅者订阅时，都会重新启动数据流。因此，每个订阅者都能看到完整的数据序列。

    **例子**：如果你创建一个基于HTTP请求的Observable，每次调用`.subscribe()`时，都会发起一个新的HTTP请求。

### Subject

1. **基本概念**：`Subject`继承自Observable，因此它既是一个Observable也是一个Observer。这意味着Subject不仅可以像Observable那样发射值，还可以订阅其他Observable。

2. **双向数据流**：与Observable不同，`Subject`可以是多播的（multicast），它可以同时作为数据源和消费者。你可以手动调用`.next()`方法来向所有的订阅者推送新的值，从而允许外部对Subject发射的数据流进行控制。

3. **热Observable**：Subject是热的（hot），这意味着它会共享单个数据流给所有订阅者。不会像冷Observable那样对每个订阅者重新发射数据，而是当一个新的值被推送时，所有的订阅者都能收到这个新值。

    **例子**：如果你有一个WebSocket连接的Subject，那么无论有多少订阅者，数据都是通过同一个WebSocket连接发送和接收的。

### 举例

为了更清楚地理解两者的差异，让我给出一个例子：

假设我们正在构建一个实时股票价格更新系统，对于股票价格的更新，我们可能会使用Subject，因为我们希望所有的订阅者看到同样的价格变动，而不需要为每个订阅者重新获取数据。

而对于用户的个人交易请求，每个请求可能都是独立的，我们可能会为每个请求创建一个新的Observable，以确保每次操作都是独立的而且互不影响。

总结来说，`Observable`适用于单向、独立的数据流，而`Subject`更适合那些需要多播或由外部主动推送数据的场景。

在流编程中有两个主要接口：**Observable**和**Observer**。

**Observable**是针对消费者的，它可以被转换和订阅：

    observable.map(x => ...).filter(x => ...).subscribe(x => ...)
    

**观察者**是用于提供可观察源的接口：

    observer.next(newItem)
    

我们可以使用**Observer创建新的****Observable**：

    var observable = Observable.create(observer => { 
        observer.next('first'); 
        observer.next('second'); 
        ... 
    });
    observable.map(x => ...).filter(x => ...).subscribe(x => ...)
    

或者，我们可以使用一个同时实现**Observable**和**Observer接口的****主题**：

    var source = new Subject();
    source.map(x => ...).filter(x => ...).subscribe(x => ...)
    source.next('first')
    source.next('second')

Observables 按设计是单播的，Subjects 按设计是多播的。

如果您查看下面的示例，您**会发现每个订阅都会收到不同的值，因为可观察量按设计开发为单播。**

    import {Observable} from 'rxjs';
    
    let obs = new Observable<any>(observer=>{
       observer.next(Math.random());
    })
    
    obs.subscribe(res=>{
      console.log('subscription a :', res); //subscription a :0.2859800202682865
    });
    
    obs.subscribe(res=>{
      console.log('subscription b :', res); //subscription b :0.694302021731573
    });
    

如果您希望两个订阅具有相同的值，这可能会很奇怪。

我们可以使用主题来解决这个问题。**主题与事件发射器类似，它不会为每个订阅调用。**考虑下面的例子。

    import {Subject} from 'rxjs';
    
    let obs = new Subject();
    
    obs.subscribe(res=>{
      console.log('subscription a :', res); // subscription a : 0.91767565496093
    });
    
    obs.subscribe(res=>{
      console.log('subscription b :', res);// subscription b : 0.91767565496093
    });
    
    obs.next(Math.random());
    

两个订阅都获得相同的输出值！

**观测值**

1.  它们很冷：当它们至少有一个观察者时，代码就会被执行。
    
2.  创建数据副本：Observable 为每个观察者创建数据副本。
    
3.  单向：观察者不能给 observable(origin/master) 赋值。
    
4.  该代码将为每个观察者运行。如果是 HTTP 调用，则每个观察者都会调用它。
    
5.  如果它是我们想要在所有组件之间共享的服务，它不会有最新结果，所有新订阅者仍然会订阅相同的可观察对象并从头开始获取价值
    
6.  单播意味着可以从 observable 发出值，而不是从任何其他组件发出值。
    

**主题**

1.  它们很热门：即使没有观察者，代码也会被执行并且值也会被广播。
    
2.  共享数据：相同的数据在所有观察者之间共享。
    
3.  双向：观察者可以为 observable（origin/master）赋值。
    
4.  如果使用主题，那么您会错过创建观察者之前广播的所有值。那么重播主题来了
    
5.  多播，可以将值投射给多个订阅者，并且可以充当订阅者和发射者

我发现接受的答案有点令人困惑！

观察者_不是用于提供_**Observable**源的接口，而是用于_观察_**Observable**源的接口……从名称**上看** ，这更有意义，对吧？

那么，原因是：

    var observable = Observable.create(observer => { 
        observer.next('first'); 
        observer.next('second'); 
        ... 
    });
    

工作原理 - 创建一个发出“第一个”然后发出“第二个”的 observable - 的参数是`Observable.create(...)`一个_subscribe 函数_，它基本上定义了哪些**Observer**事件将在该**Observable**的直接**观察者**上发生。

如果您想再深入一点，重要的是要了解订阅函数在订阅时_不会直接在_**观察者**对象上调用，而是由**订阅**对象介导，该对象可以强制执行正确的可观察规则，例如Observable在被调用后永远不会发出新值，即使你的 subscribe 函数看起来好像会发出新值**。**`observer.complete()`

参考： http: [//reactivex.io/rxjs/manual/overview.html#creating-observables](http://reactivex.io/rxjs/manual/overview.html#creating-observables)

一个**Subject**既是一个**Observable**又是一个**Observer**，它_看起来_就像**Observer接口是向****Subject** “提供”事件的方式。但是，如果您意识到一个**Subject**有点像一个**Observable**，具有相当于订阅功能的功能（即您定义观察它的事物将发生什么事件），那么它的命名就更容易理解了，它就位于对象上，即使在它之后已经被创造了。因此，您可以在**主题上调用****观察者**方法来定义观察它的事物将发生什么**观察者事件！**😊（同样，涉及中间对象，以确保您只能执行合法的事情序列。）

参考：http: [//reactivex.io/rxjs/manual/overview.html#subject](http://reactivex.io/rxjs/manual/overview.html#subject)

请参阅 rxjs 文档（那里有更多信息和示例）： [http://reactivex.io/rxjs/manual/overview.html#subject](http://reactivex.io/rxjs/manual/overview.html#subject)

> 什么是主题？RxJS主题是一种特殊类型的Observable，它允许将值多播到许多观察者。普通 Observable 是单播的（每个订阅的观察者都拥有 Observable 的独立执行），而主题是多播的。
> 
> 一个Subject就像一个Observable，但可以多播到许多观察者。主题就像 EventEmitters：它们维护许多侦听器的注册表。

和代码，`Subject`扩展`Observable`：[https://github.com/ReactiveX/rxjs/blob/master/src/internal/Subject.ts#L22](https://github.com/ReactiveX/rxjs/blob/master/src/internal/Subject.ts#L22)

    /**
     * @class Subject<T>
     */
    export class Subject<T> extends Observable<T> implements SubscriptionLike {
    //...
    }

rxjs 中的 Observable 和Subject 有什么区别？,`Observable` 和 `Subject` 都是 RxJS 库中的重要概念，它们用于处理异步事件和基于推送模型的数据流，但它们之间有一些关键区别：

### Observable

- **基础概念**: `Observable` 是 RxJS 中的基础类。它代表一个可观察的序列，可以发出三种类型的事件：值、错误和完成通知。
- **单播性质**: `Observable` 是单播的，这意味着对于每个订阅者，`Observable` 都会独立执行。如果你有多个订阅者，每个订阅者都会观察到独立的事件序列。
- **惰性运行**: `Observable` 在默认情况下是惰性的，也就是说，它只有在有订阅者时才开始执行。这与函数调用类似，只有当你调用它时，它才会运行。
- **操作符**: `Observable` 可以使用各种 RxJS 提供的操作符进行转换、合并、过滤等操作。

### Subject

- **特殊的 Observable**: `Subject` 是一种特殊类型的 `Observable`，它允许将值多播给多个观察者。这意味着当一个 `Subject` 发出一个事件时，所有的订阅者都会接收到相同的事件。
- **观察者身份**: `Subject` 也实现了 `Observer` 接口，这使它可以作为数据源，你可以明确地调用 `next(value)`、`error(e)` 和 `complete()` 方法来发出事件，这是普通 `Observable` 无法做到的。
- **热数据流**: 由于 `Subject` 是多播的，它通常代表“热”数据流。一旦值被发出，不论是否存在订阅者，该值可能会丢失。如果后来有新的订阅者，它们可能会错过之前发出的事件。
- **变种**: `Subject` 有几个变种，包括 `BehaviorSubject`、`ReplaySubject` 和 `AsyncSubject`，它们具有不同的行为特性，比如能够缓存值。

### 对比总结

- **多播与单播**: `Observable` 是单播，每个订阅者都有独立的执行上下文；而 `Subject` 是多播，多个观察者共享同一事件流。
- **主动与被动**: `Subject` 可以主动发出事件，而 `Observable` 是被动的，它通过操作符或者创建函数来发出事件。
- **热与冷**: `Observable` 通常用于表示冷数据流，而 `Subject` 表示热数据流。

在实际应用中，选择使用 `Observable` 还是 `Subject` 取决于你的特定需求，比如是否需要多播、是否需要主动控制事件的发出等。

`Observable` 和 `Subject` 都是 RxJS 库中的重要概念，它们用于处理异步事件和基于推送模型的数据流，但它们之间有一些关键区别：

### Observable

- **基础概念**: `Observable` 是 RxJS 中的基础类。它代表一个可观察的序列，可以发出三种类型的事件：值、错误和完成通知。
- **单播性质**: `Observable` 是单播的，这意味着对于每个订阅者，`Observable` 都会独立执行。如果你有多个订阅者，每个订阅者都会观察到独立的事件序列。
- **惰性运行**: `Observable` 在默认情况下是惰性的，也就是说，它只有在有订阅者时才开始执行。这与函数调用类似，只有当你调用它时，它才会运行。
- **操作符**: `Observable` 可以使用各种 RxJS 提供的操作符进行转换、合并、过滤等操作。

### Subject

- **特殊的 Observable**: `Subject` 是一种特殊类型的 `Observable`，它允许将值多播给多个观察者。这意味着当一个 `Subject` 发出一个事件时，所有的订阅者都会接收到相同的事件。
- **观察者身份**: `Subject` 也实现了 `Observer` 接口，这使它可以作为数据源，你可以明确地调用 `next(value)`、`error(e)` 和 `complete()` 方法来发出事件，这是普通 `Observable` 无法做到的。
- **热数据流**: 由于 `Subject` 是多播的，它通常代表“热”数据流。一旦值被发出，不论是否存在订阅者，该值可能会丢失。如果后来有新的订阅者，它们可能会错过之前发出的事件。
- **变种**: `Subject` 有几个变种，包括 `BehaviorSubject`、`ReplaySubject` 和 `AsyncSubject`，它们具有不同的行为特性，比如能够缓存值。

### 对比总结

- **多播与单播**: `Observable` 是单播，每个订阅者都有独立的执行上下文；而 `Subject` 是多播，多个观察者共享同一事件流。
- **主动与被动**: `Subject` 可以主动发出事件，而 `Observable` 是被动的，它通过操作符或者创建函数来发出事件。
- **热与冷**: `Observable` 通常用于表示冷数据流，而 `Subject` 表示热数据流。

在实际应用中，选择使用 `Observable` 还是 `Subject` 取决于你的特定需求，比如是否需要多播、是否需要主动控制事件的发出等。

在RxJS中，`Observable`和 `Subject`都是可观察序列的基础构建块，但它们在功能和用法上有一些关键的区别：  

### Observable

1. **基本概念**：`Observable`是RxJS提供的一种数据类型，它表示一个可随时间推送值的异步数据流。你可以订阅（subscribe）一个Observable，然后在值到来的时候通过提供的回调函数进行处理。
2. **单向数据流**：`Observable`是单向数据流的，意味着它们可以发射（emit）数据、完成（complete）或者发出错误（error），但是外部是无法直接对Observable发射的数据流进行控制的。
3. **冷Observable**：默认情况下，Observable是冷的（cold），这意味着每一个订阅者都会得到一个独立的数据流。这就是说，Observable在每次有新的订阅者订阅时，都会重新启动数据流。因此，每个订阅者都能看到完整的数据序列。

   **例子**：如果你创建一个基于HTTP请求的Observable，每次调用 `.subscribe()`时，都会发起一个新的HTTP请求。

### Subject

1. **基本概念**：`Subject`继承自Observable，因此它既是一个Observable也是一个Observer。这意味着Subject不仅可以像Observable那样发射值，还可以订阅其他Observable。
2. **双向数据流**：与Observable不同，`Subject`可以是多播的（multicast），它可以同时作为数据源和消费者。你可以手动调用 `.next()`方法来向所有的订阅者推送新的值，从而允许外部对Subject发射的数据流进行控制。
3. **热Observable**：Subject是热的（hot），这意味着它会共享单个数据流给所有订阅者。不会像冷Observable那样对每个订阅者重新发射数据，而是当一个新的值被推送时，所有的订阅者都能收到这个新值。

   **例子**：如果你有一个WebSocket连接的Subject，那么无论有多少订阅者，数据都是通过同一个WebSocket连接发送和接收的。

### 举例

为了更清楚地理解两者的差异，让我给出一个例子：

假设我们正在构建一个实时股票价格更新系统，对于股票价格的更新，我们可能会使用Subject，因为我们希望所有的订阅者看到同样的价格变动，而不需要为每个订阅者重新获取数据。

而对于用户的个人交易请求，每个请求可能都是独立的，我们可能会为每个请求创建一个新的Observable，以确保每次操作都是独立的而且互不影响。

总结来说，`Observable`适用于单向、独立的数据流，而 `Subject`更适合那些需要多播或由外部主动推送数据的场景。

What is the difference between Observable and a Subject in rxjs?

`Promise` 和 `Observable` 在异步编程中都很常见，尤其是在 JavaScript 和基于 JavaScript 的框架（如 Angular）中。尽管它们处理异步操作，但它们的工作方式和功能有所不同。以下是它们之间的一些主要区别：

### 1. 单值 vs 多值

- **Promise**:
  - Promise 代表一个异步操作的最终结果。它只处理单个异步操作并返回一个单一的值。
- **Observable**:
  - Observable 可以发出多个值，是一个流式数据集合。它可以发出零个到多个值，并且可以随着时间无限地进行。

### 2. 惰性 vs 主动

- **Promise**:
  - Promises 是不惰性的，这意味着一旦创建，它们立即执行。
- **Observable**:
  - Observables 是惰性的。Observable 执行（称为订阅）只有在有订阅者时才会开始。

### 3. 取消

- **Promise**:
  - 一旦启动，Promise 就无法取消。它要么解析一个值，要么拒绝一个错误。
- **Observable**:
  - Observables 可以被取消。订阅者可以取消订阅，这样操作就可以停止执行。

### 4. 操作符

- **Promise**:
  - Promise 在本身具有有限的操作方法，例如 `.then()`, `.catch()`, 和 `.finally()`。
- **Observable**:
  - Observable 支持广泛的操作符，如 `map()`, `filter()`, `concat()`, `flatMap()`, 等等，可以使用这些操作符来处理流中的数据。

### 5. 错误处理

- **Promise**:
  - 在 Promise 中，错误通过拒绝来处理，可以用 `.catch()` 方法来捕获。
- **Observable**:
  - 在 Observable 中，错误可以在流的任何部分被捕获，并可以使用特殊的错误处理操作符。

### 6. 使用场景

- **Promise**:
  - Promises 通常用于单一异步任务，当你对一次性事件感兴趣时使用。
- **Observable**:
  - Observables 更适合处理时间序列中的数据、用户输入、HTTP请求等，尤其是当涉及多个值或你想要处理如取消或连续的数据流时。

总的来说，Promise 更适合简单的异步转换，而 Observable 提供了更强大的控制，适用于复杂的数据流和异步事件的处理。

**承诺**

当异步操作完成或失败时，A`Promise`处理**单个事件。**

注意：有些`Promise`库支持取消，但 ES6`Promise`到目前为止还不支持。

**可观察的**

An`Observable`就像 a **`Stream`**（在许多语言中）一样，允许您传递零个或多个事件，其中为每个事件调用回调。

通常`Observable`更受青睐，`Promise`因为它提供了以下功能`Promise`以及更多功能。有了`Observable`它，无论您想处理 0 个、1 个还是多个事件都没有关系。您可以在每种情况下使用相同的 API。

`Observable``Promise`还具有可取消**的**优势。如果不再需要对服务器的 HTTP 请求或其他一些昂贵的异步操作的结果， an`Subscription`允许`Observable`您取消订阅，而 a`Promise`最终会调用成功或失败的回调，即使您不需要通知或其提供的结果不再。

a 会`Promise`立即启动，而 a`Observable`仅在您订阅后才会启动。这就是 Observables 被称为惰性的原因。

Observable 提供类似于数组的**运算符**，如`map`, `forEach`, , ...`reduce`

还有一些强大的运算符，例如`retry()`, 或`replay()`, ... 通常非常方便。 [rxjs 附带的运算符列表](https://rxjs-dev.firebaseapp.com/guide/operators)

延迟执行允许您在通过订阅执行可观察量之前构建运算符链，以进行更具声明性的编程。

和`Promises`都`Observables`为我们提供了抽象，帮助我们处理应用程序的**异步特性。**[Günter](https://stackoverflow.com/questions/37364973/what-is-the-difference-between-promises-and-observables/37365955#37365955)和 @Relu清楚地指出了它们之间的区别。

由于代码片段相当于一千个单词，让我们通过下面的示例来更容易地理解它们。

> 感谢@Christoph Burgdorf 的[精彩文章](http://blog.thoughtram.io/angular/2016/01/06/taking-advantage-of-observables-in-angular2.html)

* * *

Angular 使用 Rx.js Observables 而不是 Promise 来处理 HTTP。

假设您正在构建一个**搜索功能**，该功能应在您键入时立即显示结果。这听起来很熟悉，但这项任务会带来很多挑战。

*   我们不想每次用户按键时都访问服务器端点。它应该用大量的[HTTP](https://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol)请求淹没它们。基本上，我们只想在用户停止打字时点击它，而不是每次击键时点击它。
*   不要为后续请求使用**相同的查询参数**来访问搜索端点。
*   处理无序响应。当我们同时处理多个请求时，我们必须考虑它们以意外顺序返回的情况。想象一下，我们首先输入**Computer**，停止，一个请求发出，我们输入**car**，停止，一个请求发出。现在我们有两个请求正在处理中。**不幸的是，携带计算机**结果的请求在携带**汽车**结果的请求之后返回。

该演示仅包含两个文件：`app.ts`和`wikipedia-service.ts`. 不过，在现实世界中，我们很可能会进一步拆分事物。

* * *

下面是一个**基于 Promise 的**实现，它不处理任何所描述的边缘情况。

`wikipedia-service.ts`

    import { Injectable } from '@angular/core';
    import { URLSearchParams, Jsonp } from '@angular/http';
    
    @Injectable()
    export class WikipediaService {
      constructor(private jsonp: Jsonp) {}
    
      search (term: string) {
        var search = new URLSearchParams()
        search.set('action', 'opensearch');
        search.set('search', term);
        search.set('format', 'json');
        return this.jsonp
                    .get('http://en.wikipedia.org/w/api.php?callback=JSONP_CALLBACK', { search })
                    .toPromise()
                    .then((response) => response.json()[1]);
      }
    }
    

我们正在注入服务，以使用给定的搜索词向**维基百科 API**`Jsonp`发出[GET请求。](https://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods)请注意，我们调用是为了从 an到 a 。最终以 a作为我们搜索方法的返回类型。`toPromise``Observable<Response>``Promise<Response>``Promise<Array<string>>`

`app.ts`

    // check the plnkr for the full list of imports
    import {...} from '...';
    
    @Component({
      selector: 'my-app',
      template: `
        <div>
          <h2>Wikipedia Search</h2>
          <input #term type="text" (keyup)="search(term.value)">
          <ul>
            <li *ngFor="let item of items">{{item}}</li>
          </ul>
        </div>
      `
    })
    export class AppComponent {
      items: Array<string>;
    
      constructor(private wikipediaService: WikipediaService) {}
    
      search(term) {
        this.wikipediaService.search(term)
                             .then(items => this.items = items);
      }
    }
    

这里也没有太多惊喜。我们`WikipediaService`通过搜索方法向模板注入并公开其功能。该模板只是绑定到**keyup**并调用`search(term.value)`.

**我们解开 WikipediaService 的搜索方法返回的Promise**的结果，并将其作为简单的字符串数组公开给模板，以便我们可以`*ngFor`循环遍历它并为我们构建一个列表。

[请参阅Plunker](http://plnkr.co/edit/8ap1Lm?p=preview)上**基于 Promise**的实现示例[](http://plnkr.co/edit/8ap1Lm?p=preview)

* * *

**Observables**真正闪耀的地方

**让我们更改代码，以便每次击键时不再敲击端点，而是仅在用户停止输入400 毫秒**时发送请求

为了揭示这样的超能力，我们首先需要获取一个`Observable<string>`带有用户输入的搜索词的 。我们可以利用 Angular 的`formControl`指令，而不是手动绑定到 keyup 事件。要使用此指令，我们首先需要将其导入`ReactiveFormsModule`到我们的应用程序模块中。

`app.ts`

    import { NgModule } from '@angular/core';
    import { BrowserModule } from '@angular/platform-browser';
    import { JsonpModule } from '@angular/http';
    import { ReactiveFormsModule } from '@angular/forms';
    
    @NgModule({
      imports: [BrowserModule, JsonpModule, ReactiveFormsModule]
      declarations: [AppComponent],
      bootstrap: [AppComponent]
    })
    export class AppModule {}
    

导入后，我们可以在模板中使用 formControl 并将其设置为名称“term”。

    <input type="text" [formControl]="term"/>
    

`FormControl`在我们的组件中，我们创建一个from实例`@angular/form`，并将其公开为组件上名称 term 下的字段。

在幕后，**term**自动公开一个我们可以订阅的`Observable<string>`as 属性。`valueChanges`现在我们有了一个`Observable<string>`，克服用户输入就像调用`debounceTime(400)`我们的`Observable`. 这将返回一个新值`Observable<string>`，只有在 400 毫秒内没有出现新值时才会发出新值。

    export class App {
      items: Array<string>;
      term = new FormControl();
      constructor(private wikipediaService: WikipediaService) {
        this.term.valueChanges
                  .debounceTime(400)        // wait for 400 ms pause in events
                  .distinctUntilChanged()   // ignore if next search term is same as previous
                  .subscribe(term => this.wikipediaService.search(term).then(items => this.items = items));
      }
    }
    

如果我们的应用程序已经显示了结果，那么再发送一个搜索词请求会浪费资源。要实现所需的行为，我们所要做的就是`distinctUntilChanged`在调用后立即调用操作员`debounceTime(400)`

[请参阅Plunker](http://embed.plnkr.co/SIltBL/)上**Observable**实现的示例[](http://embed.plnkr.co/SIltBL/)

> 对于处理无序响应，请查看完整文章 [http://blog.thoughtram.io/angular/2016/01/06/take-advantage-of-observables-in-angular2.html](http://blog.thoughtram.io/angular/2016/01/06/taking-advantage-of-observables-in-angular2.html)

就我在 Angular 中使用 HTTP 而言，我同意在正常用例中使用 Observable 与 Promise 没有太大区别。这些优点在实践中都没有真正相关。我希望将来能看到一些高级用例:)

* * *

> 了解更多
> 
> *   [https://angular-2-training-book.rangle.io/handout/observables/](https://angular-2-training-book.rangle.io/handout/observables/)
> *   [https://angular.io/tutorial/toh-pt6#observables](https://angular.io/tutorial/toh-pt6#observables)

**Promises**和**Observables**都将帮助我们使用JavaScript 中的**异步功能**。它们在许多情况下非常相似，但是，两者之间仍然存在一些差异，promise 是将以`asynchronous`HTTP 调用等方式解析的值。另一方面，可观察量处理一系列**异步事件**。它们之间的主要区别如下：

**承诺：**  

*   拥有一条管道
*   通常仅与异步数据返回一起使用
*   不容易取消

**可观察到：**  

*   可以取消
*   本质上是可重试的，例如 retry 和 retryWhen
*   在多个管道中传输数据
*   具有类似数组的操作，如映射、过滤器等
*   可以从事件等其他来源创建
*   它们是函数，可以稍后订阅

另外，我在下面为您创建了图形图像，以直观地显示差异：

[![承诺和观察图像](https://i.stack.imgur.com/Ewn3b.png)](https://i.stack.imgur.com/Ewn3b.png)

答案中缺少 Observables 的一个缺点。Promise 允许使用 ES7 async/await 函数。使用它们，您可以编写异步代码，就像同步函数调用一样，因此您不再需要回调。Observables 做到这一点的唯一可能性是将它们转换为 Promise。但是当你将它们转换为 Promise 时，你只能再有一个返回值：

    async function getData(){
        const data = await observable.first().toPromise();
        //do stuff with 'data' (no callback function needed)
    }
    

进一步阅读：[如何在 Rx Observable 上“await”？](https://stackoverflow.com/questions/34190375/how-can-i-await-on-an-rx-observable)

**承诺**

1.  定义：帮助您异步运行函数，并使用它们的返回值（或异常），但**仅**在执行时使用一次。
2.  不懒惰
3.  不可取消（有 Promise 库支持取消，但 ES6 Promise 到目前为止还不支持）。两个可能的决定是
    *   拒绝
    *   解决
4.  无法**重试**（Promise 应该有权访问返回 Promise 的原始函数以具有重试功能，这是一个不好的做法）

**观测值**

1.  定义：帮助您异步运行函数，并在执行时连续（**多次**）使用它们的返回值。
2.  默认情况下，它是_惰性的_，因为它会随着时间的推移而发出值。
3.  有很多运算符，简化了编码工作。
4.  可以使用一个运算符**重试**来在需要时重试，如果我们需要根据某些条件重试可观察对象，也可以使用**retryWhen 。**

**注意**：操作员列表及其交互图可在[\*\*RxMarbles.com](http://rxmarbles.com/) \*\*上找到

What is the difference between Promises and Observables?

TailwindCSS中如何使 @apply 适用于自定义 CSS 类？,在 TailwindCSS 中，使用 `@apply` 指令可以在你的自定义CSS中应用 Tailwind 的实用工具类。要使用 `@apply` 使其适用于自定义CSS类，你需要在CSS文件中创建一个自定义类并使用 `@apply` 指令来添加所需的 Tailwind 实用工具类。

下面是一个示例，展示如何在 TailwindCSS 项目中通过 `@apply` 指令将多个实用工具类应用到一个自定义CSS类：

```css
/* 引入 Tailwind 的基础样式 */
@import 'tailwindcss/base';
@import 'tailwindcss/components';
@import 'tailwindcss/utilities';

/* 创建一个自定义的CSS类 */
.btn-custom {
  @apply bg-blue-500 text-white py-2 px-4 rounded;
}

/* 或者你也可以在响应式设计中使用它 */
.btn-responsive {
  @apply px-4 py-2;
  @apply md:px-6 md:py-3;
}
```

在这个例子中，`.btn-custom` 类将具有蓝色背景、白色文本、垂直间距 `py-2`、水平间距 `px-4`，以及圆角。`.btn-responsive` 类在移动端和桌面端有不同的内边距设置，使用 `md:` 前缀表示在中等断点（即桌面设备）时生效的样式。

请注意，使用 `@apply` 时，应该遵循一些规则：
- `@apply` 不能与复杂的选择器一起使用，例如伪类或媒体查询中的嵌套选择器。
- 只能在 CSS 规则的顶层使用 `@apply`，不能在 CSS 规则内的嵌套规则中使用。
- 不能在使用 `@apply` 的同一个规则中写入其他CSS声明，除非它们是 Tailwind 的自定义实用工具或组件。

确保在实际项目中，你已经安装了TailwindCSS并且正确配置了它的构建过程，因为TailwindCSS需要通过其构建工具来处理 `@apply` 指令。

如果没有看到您的环境或您收到的错误，我无法确定，但[规避这些问题的记录方法](https://tailwindcss.com/docs/functions-and-directives#using-apply-with-per-component-css)是在 tailwind 配置文件中定义您的类：

    // tailwind.config.cjs
    const plugin = require('tailwindcss/plugin')
    
    module.exports = {
      // ...
    
      plugins: [
        plugin(function ({ addComponents, theme }) {
          addComponents({
            '.will-change-trans': { // `will-change-transform` is now included in Tailwind CSS 3.0 so using alternative class name for this example
              willChange: 'transform'
            },
            '.ease': {
              transition: 'ease'
            },
          })
        })
      ]
    
    }
    

然后你可以在任何地方@apply这些类，就像它们是内置的一样。

（我意识到这个问题可能不再与您相关，但我在搜索时发现了它，所以这适用于其他偶然发现这个问题的人！）

How to make apply work for custom css class in tailwindcss?

在Tailwind CSS中，创建一个三角形通常涉及到利用边框属性来实现。三角形的形成其实是利用了一个小技巧：当一个元素的宽度和高度被设置为0，同时它的边框被设置不同的颜色，其中三个边框透明，另一个边框设置颜色时，这个元素就会看起来像是一个三角形。

下面是一个具体的步骤和代码示例，展示如何使用Tailwind CSS来创建一个向上指的三角形：

1. 创建一个div，给它一个宽度和高度都为0的类。
2. 应用边框宽度类到这个div上，这个宽度将决定了三角形的大小。
3. 给div的三个边框设置透明颜色，给剩下的一个边框设置一个实际的颜色。

以下是一个实现上述步骤的Tailwind CSS代码示例：

```html

<div class="w-0 h-0 border-l-8 border-r-8 border-b-8 border-l-transparent border-r-transparent border-b-indigo-600"></div>
```

在这个例子中：

- `w-0` 和 `h-0` 类设置元素宽度和高度为0。
- `border-l-8` 和 `border-r-8` 类设置左右边框宽度为8个单位，这里的单位根据你的Tailwind CSS配置而定，通常是以px为单位。
- `border-b-8` 类设置下边框宽度，这个宽度实际上决定了三角形的大小。
- `border-l-transparent` 和 `border-r-transparent` 类将左右边框设置为透明。
- `border-b-indigo-600` 类设置下边框颜色为indigo（靛蓝色），这将成为三角形的颜色。

可以根据你的需求调整边框的宽度和颜色类，来改变三角形的大小和颜色。如果你需要不同方向的三角形（向下、向左、向右指的三角形），只需调整哪个边框是可见的，哪三个是透明的即可。

您可以尝试使用转换：

显示代码片段

    <link href="https://unpkg.com/tailwindcss@^2/dist/tailwind.min.css" rel="stylesheet">
    <div class="w-16 overflow-hidden inline-block">
     <div class=" h-11 w-11 bg-black rotate-45 transform origin-bottom-left"></div>
    </div>
    
    <div class="w-16 overflow-hidden inline-block">
     <div class=" h-11 w-11 bg-black -rotate-45 transform origin-top-left"></div>
    </div>
    
    <div class="w-11  overflow-hidden inline-block">
     <div class=" h-16  bg-black -rotate-45 transform origin-top-right"></div>
    </div>
    
    <div class="w-11  overflow-hidden inline-block">
     <div class=" h-16  bg-black rotate-45 transform origin-top-left"></div>
    </div>
    
    <div class="w-11  overflow-hidden inline-block">
     <div class=" h-16  bg-black -rotate-45 transform origin-bottom-right"></div>
    </div>
    
    <div class="w-11  overflow-hidden inline-block">
     <div class=" h-16  bg-black rotate-45 transform origin-bottom-left"></div>
    </div>
    
    <div class="w-11  overflow-hidden inline-block">
     <div class=" h-16  bg-black -rotate-45 transform origin-top-left"></div>
    </div>
    
    <div class="w-11  overflow-hidden inline-block">
     <div class=" h-16  bg-black rotate-45 transform origin-top-right"></div>
    </div>

Run code snippetHide results

Expand snippet

但仅使用 CSS 会更容易。您所需要的只是两个属性，您可以从这里获取许多三角形的代码： https: [//css-generators.com/triangle-shapes/](https://css-generators.com/triangle-shapes/)

您也可以尝试使用边框

[顺风游乐场](https://play.tailwindcss.com/RCiIARRSxx)

    
    <div class="border-solid border-t-black border-t-8 border-x-transparent border-x-8 border-b-0"></div>
    
    <div class="border-solid border-b-black border-b-8 border-x-transparent border-x-8 border-t-0"></div>
    
    <div class="border-solid border-r-black border-r-8 border-y-transparent border-y-8 border-l-0"></div>
    
    <div class="border-solid border-l-black border-l-8 border-y-transparent border-y-8 border-r-0"></div>

通过伪元素（小三角形）：

    <script src="https://cdn.tailwindcss.com"></script>
    <div>small triangle:</div>
    <div class="flex gap-x-1">
      <div class="before:content-['▴']"></div>
      <div class="before:content-['▾']"></div>
      <div class="before:content-['◂']"></div>
      <div class="before:content-['▸']"></div>
    </div>

运行代码片段Hide results

展开片段

* * *

通过伪元素（普通三角形）：

    <script src="https://cdn.tailwindcss.com"></script>
    
    <div>normal triangle:</div>
    <div class="flex gap-x-1">
      <div class="before:content-['▲']"></div>
      <div class="before:content-['▼']"></div>
      <div class="before:content-['◀']"></div>
      <div class="before:content-['▶']"></div>
    </div>

运行代码片段Hide results

展开片段

* * *

按边界：

    <script src="https://cdn.tailwindcss.com"></script>
    <div>triangle by border</div>
    <div class="flex gap-x-3">
      <div class="w-0 h-0 border-8 border-solid border-transparent border-b-black"></div>
      <div class="w-0 h-0 border-8 border-solid border-transparent border-t-black"></div>
      <div class="w-0 h-0 border-8 border-solid border-transparent border-r-black"></div>
      <div class="w-0 h-0 border-8 border-solid border-transparent border-l-black"></div>
    </div>

运行代码片段Hide results

展开片段

* * *

按边界（简化）：

    <script src="https://cdn.tailwindcss.com"></script>
    
    <div>triangle by border (simplify)</div>
    <style type="text/tailwindcss">
      @layer components { .triangle { @apply w-0 h-0 border-8 border-solid border-transparent } }
    </style>
    <div class="flex gap-x-3">
      <div class="triangle border-b-black"></div>
      <div class="triangle border-t-black"></div>
      <div class="triangle border-r-black"></div>
      <div class="triangle border-l-black"></div>
    </div>

运行代码片段Hide results

展开片段

也许您想使用三角形作为工具提示。（这样的搜索让我来到这里）：

[![在此输入图像描述](https://i.stack.imgur.com/BNxlB.png)](https://i.stack.imgur.com/BNxlB.png)

    <div class="group relative mt-4 ml-4 inline-block">
      <button type="button" class="rounded-md border border-neutral-600 px-1">...</button>
    
      
      <div class="invisible absolute left-0 -mt-[2px] flex flex-col group-focus-within:visible group-active:visible">
         <div class="ml-2 -mb-[1px] inline-block overflow-hidden"> 
            
          <div class="h-3 w-3 origin-bottom-left rotate-45 transform border border-neutral-500 bg-neutral-100"></div>
        </div>
    
        
        <div class="flex min-w-max flex-col rounded-md border border-neutral-500 bg-neutral-100 px-2 py-1">
          <div class="cursor-pointer hover:underline">Do amazing stuff</div>
          <div class="cursor-pointer hover:underline">Go back</div>
        </div>
      </div>
    </div>
    

[play.tai​​lwindcss.com 上的演示](https://play.tailwindcss.com/KO8cXX7sBN)

基于：

*   @temani-afif[答案](https://stackoverflow.com/a/67133568/1154773)
*   [https://github.com/tesar-tech/BlazorAndTailwind/blob/master/Articles/DropdownMenu/README.md](https://github.com/tesar-tech/BlazorAndTailwind/blob/master/Articles/DropdownMenu/README.md)

How to make a triangle shape with tailwind

在使用TailwindCSS时，您可以通过在`tailwind.config.js`文件中扩展它的默认主题来创建自定义百分比的`padding`类。Tailwind 已经为您提供了一组预定义的`padding`工具类，但如果您需要使用特定的百分比值来设置`padding`，您可以按照以下步骤操作：

1. 打开您的项目中的`tailwind.config.js`文件。
2. 定位到`theme`部分。
3. 扩展`padding`属性以包含您希望使用的百分比值。

以下是一个具体的例子：

```javascript
// tailwind.config.js
module.exports = {
  theme: {
    extend: {
      padding: {
        '5p': '5%',   // 创建一个名为 'p-5p' 的工具类，对应 5% 的 padding
        '10p': '10%', // 创建一个名为 'p-10p' 的工具类，对应 10% 的 padding
        // 你可以继续添加更多自定义的百分比
      }
    }
  },
  variants: {},
  plugins: [],
}
```

在上面的配置中，我们添加了两个自定义的`padding`百分比类：`p-5p`和`p-10p`。现在，您可以在您的HTML中使用这些类，就像使用Tailwind的其他工具类一样。

例如：

```html
<div class="p-5p bg-gray-200">这个盒子有5%的padding</div>
<div class="p-10p bg-gray-300">这个盒子有10%的padding</div>
```

在上述的HTML代码中，第一个`div`将会有等于其宽度5%的`padding`，第二个`div`将会有等于其宽度10%的`padding`。

请注意，当您添加自定义配置时，最好遵守Tailwind的命名约定，即`p-{size}`用于`padding`，`m-{size}`用于`margin`等等，以保持一致性和可预测性。同时，确保在项目构建过程中，您的`tailwind.config.js`文件被正确引入和处理，以便生成相应的CSS。

虽然其他答案确实提供了答案，但如果您只需要使用自定义值一次，这可能会令人沮丧。我在尝试解决这样的问题时找到了这个答案，因此对于那些在我之后发现这个问题的人来说， tailwind 现在支持[任意值](https://tailwindcss.com/docs/padding#arbitrary-values)。

您可以通过将包含 CSS 值（例如 ）的方括号附加`[80%]`到前缀（例如`p-`用于 padding 或`mr-`margin-right）来使用它们。

    <div class="p-[80%]">
        Hello world!
    </div>

对于 Tailwind，您不需要转义百分号，它会处理这个问题。这是一个播放示例[https://play.tai​​lwindcss.com/CYR6JOXYyz?file=config](https://play.tailwindcss.com/CYR6JOXYyz?file=config)

    theme: {
      extend: {
        spacing: {
          '80%': '80%', // p-80% - should work
        }
      },
    },
    

`.p-80\%`Tailwind 将为上述配置创建类。

我发现使用间距可以[一次性自定义更多的内容：内边距、](https://tailwindcss.com/docs/padding#padding-scale)_边距、宽度和高度_[](https://tailwindcss.com/docs/padding#padding-scale)

代码

    const defaultTheme = require('tailwindcss/defaultTheme')
    
    module.exports = {
      theme: {
         extend: {
          padding: {
            'p-80': '80%',
          },
          // Build your palette here
              colors: {
          'black': '#393939',
        }
      }
      }
    }
    

标记

    <a href="#" class="p-80">TailWindCSS Dev</a>

How to use custom percentages in padding in TailwindCSS?

在 Tailwind CSS 中，某些类名包含一个反斜线 (`\`) 是因为它们用来转义 HTML 和 CSS 中的特殊字符，以确保类名是有效的。

例如，在 Tailwind CSS 中，你可能会看到像 `md\:bg-red-500` 这样的类名。这里的反斜杠是用来转义冒号 (`:`)，因为在不同的断点上应用样式时，Tailwind 使用冒号来作为前缀。直接在 CSS 类名中使用冒号是不合法的，所以它必须被转义。

这里是一些为什么要使用转义字符的例子：

- **响应式前缀**: 如 `sm:`, `md:`, `lg:`, `xl:` 等，用于在不同的屏幕尺寸下应用样式。
- **状态变量前缀**: 如 `hover:`, `focus:`, `active:` 等，用于定义某个状态下的样式。
- **分数**: 如 `w-1/2`，在这个类名中，`1/2` 表示宽度为容器的一半，`/` 被转义以防止与 CSS 语法冲突。
- **负数值**: 如 `-mt-4`，用于表示负的 `margin-top`。在这个类名中，`-` 被转义以确保类名的有效性。

在你编写 HTML 时，不需要添加反斜杠；这些只是在 Tailwind CSS 的配置和生成的 CSS 文件中使用。当你在 HTML 使用这些类时，应当这样写：

```html
<div class="md:bg-red-500"></div>
```

而不是：

```html
<div class="md\:bg-red-500"></div>
```

总之，反斜线在 Tailwind CSS 类名中的使用是为了确保包含特殊字符的类名在 CSS 文件中是合法和有效的。

Tailwind 使用带有冒号的类名作为其对响应式设计支持的一部分。特别是类名，例如

    tablet:bold
    

`bold`意味着应该应用类中定义的属性，但前提是媒体与定义为 的媒体查询匹配`tablet`。

冒号是 HTML5 类名中完全有效的字符。然而，它是 CSS 选择器中的保留字符。因此，如果要选择名称中包含冒号的类的元素，则需要转义冒号。

所以，如果你有这样的 HTML：

    <p class="one:two"></p>
    

如果您想要选择该元素，相应的查询选择器将类似于：

    .one\:two

Why is there a back slash in tailwind css class names?

要在TailwindCSS中实现下划线悬停动画，我们可以利用其类的实用性和定制性。下面是一个基本示例，展示了如何创建一个当鼠标悬停时逐渐出现下划线的动画：

```html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Tailwind CSS 下划线悬停动画</title>

<link href="https://cdn.jsdelivr.net/npm/tailwindcss@latest/dist/tailwind.min.css" rel="stylesheet">

<style>
  /* 在Tailwind配置中扩展这些类 */
  .hover-underline-animation {
    display: inline-block;
    position: relative;
    color: #3490dc;
    text-decoration: none;
  }

  .hover-underline-animation::after {
    content: '';
    position: absolute;
    width: 100%;
    transform: scaleX(0);
    height: 2px;
    bottom: 0;
    left: 0;
    background-color: #3490dc;
    transform-origin: bottom right;
    transition: transform 0.25s ease-out;
  }

  .hover-underline-animation:hover::after {
    transform: scaleX(1);
    transform-origin: bottom left;
  }
</style>
</head>
<body class="flex items-center justify-center h-screen">
  
  <a href="#" class="hover-underline-animation text-xl">
    悬停我查看下划线动画
  </a>
</body>
</html>
```

在上述代码中，我们定义了一个`hover-underline-animation`类，可以添加到任何你想要应用悬停下划线动画的元素上。这个类使用了伪元素`:after`来在悬停时显示下划线，并通过`transform`属性来控制下划线的动画效果。使用`transition`属性让动画平滑进行。

当然，你也可以使用TailwindCSS的`@apply`指令来在CSS中直接应用Tailwind的工具类，或者通过TailwindCSS的配置文件`tailwind.config.js`来扩展你的类。这些方式可以让你保持CSS的一致性并充分利用TailwindCSS提供的功能。

您可以使用组 max-w-{x} 和transition-all 在纯 TailwindCSS 中实现这一点，在跨度上使用组悬停，这样当您经过链接时它就会启动动画

```
<a href="#" class="group text-sky-600 transition duration-300">
Link
<span class="block max-w-0 group-hover:max-w-full transition-all duration-500 h-0.5 bg-sky-600"></span>
</a>
```

如果您不想仅包含用于此功能的 CSS 文件，或者您只想在 Tailwind 中执行此操作 - 我在下面发布的代码片段纯粹基于 Tailwind CSS。

    <a class="group text-pink-500 transition-all duration-300 ease-in-out" href="#">
      <span class="bg-left-bottom bg-gradient-to-r from-pink-500 to-pink-500 bg-[length:0%_2px] bg-no-repeat group-hover:bg-[length:100%_2px] transition-all duration-500 ease-out">
        This text gets 'underlined' on hover
      </span>
    </a>
    

干杯，编码愉快！

你可以为此过渡：

        .link-underline {
            border-bottom-width: 0;
            background-image: linear-gradient(transparent, transparent), linear-gradient(#fff, #fff);
            background-size: 0 3px;
            background-position: 0 100%;
            background-repeat: no-repeat;
            transition: background-size .5s ease-in-out;
        }
    
        .link-underline-black {
            background-image: linear-gradient(transparent, transparent), linear-gradient(#F2C, #F2C)
        }
    
        .link-underline:hover {
            background-size: 100% 3px;
            background-position: 0 100%
        }

    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/tailwindcss/2.2.19/tailwind.min.css" integrity="sha512-wnea99uKIC3TJF7v4eKk4Y+lMz2Mklv18+r4na2Gn1abDRPPOeef95xTzdwGD9e6zXJBteMIhZ1+68QC5byJZw==" crossorigin="anonymous" referrerpolicy="no-referrer" />
    
    <div class="min-h-screen bg-gray-100 py-6 flex flex-col justify-center sm:py-12">
        <div class="relative py-3 sm:max-w-xl sm:mx-auto">
            <a href="#" class="font-display max-w-sm text-2xl font-bold leading-tight">
                <span class="link link-underline link-underline-black text-black"> Link Hover Effect </span>
            </a>
        </div>
    </div>

运行代码片段Hide results

展开片段

您可以使用伪元素在一行中完成所有操作`after`：

    <section class="bg-[#0077b6] h-screen w-screen text-white flex items-center justify-center">
      <a class="text-3xl relative after:bg-white after:absolute after:h-1 after:w-0 after:bottom-0 after:left-0 hover:after:w-full after:transition-all after:duration-300 cursor-pointer">Text you want to underline in just one line</a>
    </section>
    

这是一支带有用例的笔：

[https://codepen.io/Marcos-Riverola/pen/poQmRKV?editors=1010](https://codepen.io/Marcos-Riverola/pen/poQmRKV?editors=1010)

How to using underline hover animation in tailwindcss

当您想要在 Tailwind CSS 中创建多个主题时，可以使用几种不同的方法，例如利用 Tailwind CSS 的官方插件或利用其内建的工具如变体(variants)和配置文件。以下是一个具体的步骤示例：

### 使用 Tailwind CSS 官方插件：`@tailwindcss/custom-forms`

1. **安装插件**：
   首先，您需要安装这个插件。如果您还没有安装 Tailwind CSS，请先安装它。

   ```shell
   npm install tailwindcss @tailwindcss/custom-forms
   ```

2. **在配置文件中引入插件**：
   在 `tailwind.config.js` 文件中引入这个插件。

   ```javascript
   // tailwind.config.js
   module.exports = {
     // ...
     plugins: [
       // ...
       require('@tailwindcss/custom-forms'),
     ],
   };
   ```

3. **配置多个主题**：
   Tailwind CSS 使用类名前缀来创建多个主题，您可以在配置文件中自定义这些前缀。

   ```javascript
   // tailwind.config.js
   module.exports = {
     // ...
     darkMode: 'class', // or 'media' if you prefer to use media queries
     theme: {
       extend: {
         // Define the colors for the light theme
         colors: {
           theme1: {
             'primary': '#...', // Define primary color
             'secondary': '#...', // Define secondary color
             // ... more colors
           },
           // Define the colors for the dark theme
           theme2: {
             'primary': '#...', // Define primary color
             'secondary': '#...', // Define secondary color
             // ... more colors
           },
         },
       },
     },
     variants: {
       // Define which utilities should be generated for your themes
       extend: {
         backgroundColor: ['theme1', 'theme2'],
         borderColor: ['theme1', 'theme2'],
         textColor: ['theme1', 'theme2'],
         // ... other utilities
       },
     },
   };
   ```

4. **使用主题相关的类名**：
   在您的 HTML 或模板文件中，根据需要使用相应的类名来切换主题。

   ```html
   
   <button class="bg-theme1-primary text-white">
     Theme 1 Button
   </button>

   
   <button class="bg-theme2-primary text-white">
     Theme 2 Button
   </button>
   ```

### 利用 CSS 变量和 JavaScript 控制主题

另一种方式是使用 CSS 变量来定义颜色，然后使用 JavaScript 来切换这些变量的值。

1. **定义 CSS 变量**：
   在您的 CSS 文件中，您可以这样定义主题颜色：

   ```css
   :root {
     --primary-color: #...; /* 默认主题颜色 */
     --secondary-color: #...;
     /* ... */
   }
   .theme1 {
     --primary-color: #...; /* 主题1颜色 */
     --secondary-color: #...;
     /* ... */
   }
   .theme2 {
     --primary-color: #...; /* 主题2颜色 */
     --secondary-color: #...;
     /* ... */
   }
   ```

2. **在 HTML 中使用 CSS 变量**：

   ```html
   <button style="background-color: var(--primary-color); color: white;">
     Theme Button
   </button>
   ```

3. **使用 JavaScript 切换主题**：
   您可以根据用户的选择或某些条件来使用 JavaScript 切换主题。

   ```javascript
   // 切换到主题1
   document.documentElement.classList.add('theme1');
   document.documentElement.classList.remove('theme2');

   // 切换到主题2
   document.documentElement.classList.add('theme2');
   document.documentElement.classList.remove('theme1');
   ```

使用上述方法，您可以根据需要创建并切换不同的主题。这可以通过类名控制，CSS 变量，甚至可以用 JavaScript 动态切换，以满足更复杂的应用场景。除了使用官方插件和 CSS 变量以外，还有一种方法是直接在 Tailwind CSS 的配置文件中使用 JavaScript 来动态生成主题。这种方法通常涉及条件逻辑和自定义函数，使得配置更灵活。

### 使用 JavaScript 动态生成主题

1. **配置多个主题**：
   在 Tailwind 的配置文件中，您可以使用 JavaScript 来根据不同的条件动态生成主题配置。

   ```javascript
   // tailwind.config.js
   function generateTheme(themeName) {
     return {
       'primary': themeName === 'theme1' ? '#...' : '#...',
       'secondary': themeName === 'theme1' ? '#...' : '#...',
       // ...
     };
   }

   module.exports = {
     theme: {
       extend: {
         colors: {
           theme1: generateTheme('theme1'),
           theme2: generateTheme('theme2'),
         },
         // ...
       },
     },
     // ...
   };
   ```

2. **应用主题相关的类名**：
   在您的 HTML 或模板文件中，根据需要使用相应的类名来应用不同的主题。

   ```html
   
   <div class="theme1:primary">This text uses the primary color of theme 1</div>
   
   <div class="theme2:primary">This text uses the primary color of theme 2</div>
   ```

### 使用插件创建基于条件的主题

Tailwind CSS 允许开发者编写自定义插件，这意味着您可以创建一个插件来根据特定条件或环境变量来生成主题。

1. **编写自定义插件**：
   创建一个新的 JavaScript 文件来编写您的插件逻辑。

   ```javascript
   // plugins/themePlugin.js
   module.exports = function({ addBase, config }) {
     const theme = config('themeName');
     addBase({
       h1: { color: config(`theme.${theme}.primary`) },
       // ...其他基础样式
     });
   };
   ```

2. **在配置文件中引入自定义插件**：
   修改您的 `tailwind.config.js` 文件以包含您的插件，并传递所需的配置。

   ```javascript
   // tailwind.config.js
   const themePlugin = require('./plugins/themePlugin');

   module.exports = {
     themeName: 'theme1', // 或者 'theme2', 可能来自环境变量或其他逻辑
     // ...
     plugins: [
       themePlugin,
       // ...其他插件
     ],
     // ...
   };
   ```

### 结合使用 Tailwind CSS 和其它 CSS 方法

在实际项目中，Tailwind CSS 可以与其他 CSS 方法(如 CSS-in-JS 或者传统的样式表)结合使用。例如，您可以使用 Tailwind 的实用类来处理大部分样式，同时使用组件级别的样式表来管理特定的主题样式。

在以上所有情况中，关键是理解 Tailwind 的配置方式和类生成机制。您可以根据项目需求灵活搭配不同的方法，创建符合设计需求的多主题界面。

我确实找到了使用 CSS 变量的解决方案。

在 CSS 文件中，您可以为每个主题定义样式，如下所示

    @tailwind base;
    @tailwind components;
    @tailwind utilities;
    
    @layer base {
      html[data-theme='default'] {
        --color-esther: 34, 39, 46;
        --color-maximus: 45, 51, 59;
        --color-linx: 55, 62, 71;
      }
    
      html[data-theme='neon'] {
        --color-esther: 20, 61, 42;
        --color-maximus: 13, 82, 66;
        --color-linx: 20, 82, 11;
      }
    }
    

然后在你的`tailwind.config.js`文件中你可以这样定义它们

**顺风版本^3.1**

    module.exports = {
      theme: {
        colors: {
          esther: 'rgb(var(--color-esther) / <alpha-value>)',
          maximus: 'rgb(var(--color-maximus) / <alpha-value>)',
          linx: 'rgb(var(--color-linx) / <alpha-value>)',
        },
      },
    }
    

**Tailwind 低于 3.1 版本**

    function withOpacity(cssVariable) {
      return ({ opacityValue }) => {
        return opacityValue ? `rgba(var(${cssVariable}), ${opacityValue})` : `rgb(var(${cssVariable}))`
      }
    }
    
    module.exports = {
      theme: {
        colors: {
          esther: withOpacity('--color-esther'),
          maximus: withOpacity('--color-maximus'),
          linx: withOpacity('--color-linx'),
        },
      },
    }
    

在 HTML 中，您可以像这样使用这些类：

    <html lang="en" data-theme="default">
      <body class="bg-esther text-optimus cursor-default"></body>
    </html>

[tw-colors](https://www.npmjs.com/package/tw-colors)正是这样做的。

_tailwind.config.js_

    const { createThemes } = require('tw-colors');
    
       module.exports = {
          content: ['./src/**/*.{astro,html,js,jsx,md,mdx,svelte,ts,tsx,vue}'],
          plugins: [
             createThemes({
                halloween: { 
                   'primary': 'orange',
                   'secondary': 'yellow',
                },
                summer: { 
                   'primary': 'pink',
                   'secondary': 'red',
                },
                winter: { 
                   'primary': 'blue',
                   'secondary': 'green',
                },
                party: { 
                   'primary': 'steelblue',
                   'secondary': 'darkblue',
                },
             })
          ],
       };
    

在类中使用这样的主题：

    <html class='theme-halloween'>
          ...
    </html>
    

或者使用数据属性：

    <html data-theme='halloween'>
          ...
    </html>
    

然后像平常一样使用顺风课程。具有该类的按钮`bg-primary`将根据最接近的主题改变颜色。

可以使用一些切换按钮或您喜欢的任何内容动态切换主题

有几个插件支持定义多个 Tailwind 主题并在它们之间进行切换。我特别喜欢[tailwindcss-themer 插件，](https://github.com/RyanClementsHax/tailwindcss-themer)因为它允许您：

*   只需在任何组件（通常是顶级组件）上添加带有主题名称的 css 类即可切换主题
*   像平常一样使用 CSS 类（例如`text-primary`）。这使代码保持干净并且独立于插件（与其他插件相反，其他插件有时需要每个 CSS 类都有特定的前缀）
*   使用变体进一步微调样式，例如`my-theme:font-bold`

只是偶然发现了这个问题，因为我正在做与几年前相同的事情，但我不记得了。如果有人再次来到这里，也许这个答案可能会有所帮助。

在我们的例子中，我们正在构建一个应用于 3 个不同网站的主题，但明显改变了颜色和字体，这似乎与问题作者的情况相同。

为此，可以使用[顺风预设。](https://tailwindcss.com/docs/presets)我有一个`tailwind.preset.js`基本上是默认的顺风配置，具有所有基色、间距等。对于每个主题，`tailwind.<theme-name>.js`都会设置一个单独的主题，其中包含更改并基于预设。

例子`tailwind.theme-one.js`：

    module.exports = {
      presets: [
        require('./tailwind.preset.js')
      ],
      theme: {
        colors: {
          # color changes go here
        }
      }
    }
    

我们设置了一个 gulp 工作流程，基本上只为每个主题配置渲染一次主 scss 文件。在集成上，随后将加载所需的主题文件。

当您想要在 Tailwind CSS 中创建多个主题时，可以使用几种不同的方法，例如利用 Tailwind CSS 的官方插件或利用其内建的工具如变体(variants)和配置文件。以下是一个具体的步骤示例：

### 使用 Tailwind CSS 官方插件：`@tailwindcss/custom-forms`

1. **安装插件**：
   首先，您需要安装这个插件。如果您还没有安装 Tailwind CSS，请先安装它。

   ```shell
   npm install tailwindcss @tailwindcss/custom-forms
   ```

2. **在配置文件中引入插件**：
   在 `tailwind.config.js` 文件中引入这个插件。

   ```javascript
   // tailwind.config.js
   module.exports = {
     // ...
     plugins: [
       // ...
       require('@tailwindcss/custom-forms'),
     ],
   };
   ```

3. **配置多个主题**：
   Tailwind CSS 使用类名前缀来创建多个主题，您可以在配置文件中自定义这些前缀。

   ```javascript
   // tailwind.config.js
   module.exports = {
     // ...
     darkMode: 'class', // or 'media' if you prefer to use media queries
     theme: {
       extend: {
         // Define the colors for the light theme
         colors: {
           theme1: {
             'primary': '#...', // Define primary color
             'secondary': '#...', // Define secondary color
             // ... more colors
           },
           // Define the colors for the dark theme
           theme2: {
             'primary': '#...', // Define primary color
             'secondary': '#...', // Define secondary color
             // ... more colors
           },
         },
       },
     },
     variants: {
       // Define which utilities should be generated for your themes
       extend: {
         backgroundColor: ['theme1', 'theme2'],
         borderColor: ['theme1', 'theme2'],
         textColor: ['theme1', 'theme2'],
         // ... other utilities
       },
     },
   };
   ```

4. **使用主题相关的类名**：
   在您的 HTML 或模板文件中，根据需要使用相应的类名来切换主题。

   ```html
   
   <button class="bg-theme1-primary text-white">
     Theme 1 Button
   </button>

   
   <button class="bg-theme2-primary text-white">
     Theme 2 Button
   </button>
   ```

### 利用 CSS 变量和 JavaScript 控制主题

另一种方式是使用 CSS 变量来定义颜色，然后使用 JavaScript 来切换这些变量的值。

1. **定义 CSS 变量**：
   在您的 CSS 文件中，您可以这样定义主题颜色：

   ```css
   :root {
     --primary-color: #...; /* 默认主题颜色 */
     --secondary-color: #...;
     /* ... */
   }
   .theme1 {
     --primary-color: #...; /* 主题1颜色 */
     --secondary-color: #...;
     /* ... */
   }
   .theme2 {
     --primary-color: #...; /* 主题2颜色 */
     --secondary-color: #...;
     /* ... */
   }
   ```

2. **在 HTML 中使用 CSS 变量**：

   ```html
   <button style="background-color: var(--primary-color); color: white;">
     Theme Button
   </button>
   ```

3. **使用 JavaScript 切换主题**：
   您可以根据用户的选择或某些条件来使用 JavaScript 切换主题。

   ```javascript
   // 切换到主题1
   document.documentElement.classList.add('theme1');
   document.documentElement.classList.remove('theme2');

   // 切换到主题2
   document.documentElement.classList.add('theme2');
   document.documentElement.classList.remove('theme1');
   ```

使用上述方法，您可以根据需要创建并切换不同的主题。这可以通过类名控制，CSS 变量，甚至可以用 JavaScript 动态切换，以满足更复杂的应用场景。
除了使用官方插件和 CSS 变量以外，还有一种方法是直接在 Tailwind CSS 的配置文件中使用 JavaScript 来动态生成主题。这种方法通常涉及条件逻辑和自定义函数，使得配置更灵活。

### 使用 JavaScript 动态生成主题

1. **配置多个主题**：
   在 Tailwind 的配置文件中，您可以使用 JavaScript 来根据不同的条件动态生成主题配置。

   ```javascript
   // tailwind.config.js
   function generateTheme(themeName) {
     return {
       'primary': themeName === 'theme1' ? '#...' : '#...',
       'secondary': themeName === 'theme1' ? '#...' : '#...',
       // ...
     };
   }

   module.exports = {
     theme: {
       extend: {
         colors: {
           theme1: generateTheme('theme1'),
           theme2: generateTheme('theme2'),
         },
         // ...
       },
     },
     // ...
   };
   ```

2. **应用主题相关的类名**：
   在您的 HTML 或模板文件中，根据需要使用相应的类名来应用不同的主题。

   ```html
   
   <div class="theme1:primary">This text uses the primary color of theme 1</div>
   
   <div class="theme2:primary">This text uses the primary color of theme 2</div>
   ```

### 使用插件创建基于条件的主题

Tailwind CSS 允许开发者编写自定义插件，这意味着您可以创建一个插件来根据特定条件或环境变量来生成主题。

1. **编写自定义插件**：
   创建一个新的 JavaScript 文件来编写您的插件逻辑。

   ```javascript
   // plugins/themePlugin.js
   module.exports = function({ addBase, config }) {
     const theme = config('themeName');
     addBase({
       h1: { color: config(`theme.${theme}.primary`) },
       // ...其他基础样式
     });
   };
   ```

2. **在配置文件中引入自定义插件**：
   修改您的 `tailwind.config.js` 文件以包含您的插件，并传递所需的配置。

   ```javascript
   // tailwind.config.js
   const themePlugin = require('./plugins/themePlugin');

   module.exports = {
     themeName: 'theme1', // 或者 'theme2', 可能来自环境变量或其他逻辑
     // ...
     plugins: [
       themePlugin,
       // ...其他插件
     ],
     // ...
   };
   ```

### 结合使用 Tailwind CSS 和其它 CSS 方法

在实际项目中，Tailwind CSS 可以与其他 CSS 方法(如 CSS-in-JS 或者传统的样式表)结合使用。例如，您可以使用 Tailwind 的实用类来处理大部分样式，同时使用组件级别的样式表来管理特定的主题样式。

在以上所有情况中，关键是理解 Tailwind 的配置方式和类生成机制。您可以根据项目需求灵活搭配不同的方法，创建符合设计需求的多主题界面。

How to create multiple themes using tailwind css

在React中使用TailwindCSS动态设置背景图像通常涉及到几个步骤。但是，TailwindCSS默认情况下并不直接支持将动态URL用作背景图像，因为它使用PurgeCSS来删除未使用的样式，并且希望在构建时能知道所有可能的类名。要解决这个问题，我们可以使用内联样式或通过修改Tailwind配置来生成必要的背景图像类。下面我将介绍两种方法。

### 方法一：使用内联样式

这是设置动态背景图像的最简单方法，因为它不需要修改TailwindCSS的配置。你可以直接在React组件中使用内联样式来设置背景图像：

```jsx
function MyComponent({ imageUrl }) {
  // 使用内联样式直接设置背景图像
  const style = {
    backgroundImage: `url(${imageUrl})`,
    // 其它你想要添加的TailwindCSS样式
  };

  return <div style={style} className="bg-no-repeat bg-center bg-cover ...">...</div>;
}
```

### 方法二：通过TailwindCSS配置

如果你想使用Tailwind的工具类而不是内联样式，那么你需要在你的`tailwind.config.js`文件中动态地生成背景图像类：

```js
// tailwind.config.js
module.exports = {
  // 其它配置...
  theme: {
    extend: {
      backgroundImage: theme => ({
        'dynamic-pattern': "url('/path/to/image.jpg')", // 用实际的图像路径替换这里
        // 你可以根据需要添加更多背景图像
      }),
    },
  },
  // 其它配置...
}
```

然后在你的React组件中使用这个自定义的背景图像类：

```jsx
function MyComponent() {
  // 假设你已经在tailwind.config.js中添加了名为'dynamic-pattern'的背景图像
  return <div className="bg-dynamic-pattern bg-no-repeat bg-center bg-cover ...">...</div>;
}
```

要使这个方法更加动态，你可以编写一个小的函数，它根据图像URL生成一个唯一的类名，并在构建过程中将此类名和URL添加到配置文件中。然而，这种方法可能会导致配置文件的大小显著增加，并且需要一些自定义逻辑来处理图像URL的插入和类名的生成。

### 注意

两种方法都有其优缺点。使用内联样式是最直接的方法，但它不会利用到Tailwind的PurgeCSS能力，可能会导致样式文件体积增加。通过TailwindCSS配置可能会更符合Tailwind的工作流程，但它可能需要额外的设置，并且在构建时需要知道所有可能的背景图像URL，这可能在某些动态场景下不实际。

选择哪种方法取决于你的具体需求和项目设置。如果背景图像是用户动态生成的内容，方法一可能更合适。如果背景图像可以预先知道，或者是有限的选择集，方法二可能是一个更好的选择。

I think I have found a solution other than simply using a style attribute.

    <div
      style={{'--image-url': `url(${fetchedUrl})`}} 
      className='bg-[image:var(--image-url)]'>
        
    </div>
    

This works perfectly fine.

Although it looks a bit tedious, it can be used to enable the background image on hover, focus, etc. In which the style attribute is incapable of.

    className='hover:bg-[image:var(--image-url)] focus:bg-[image:var(--image-url)] ...'
    

This application of custom properties can be used for implementing dynamic values with tailwind like colors fetched from an API.

    <div
      style={{'--color': fetchedColor}} 
      className='text-[color:var(--color)]'>
        
    </div>

I think the best solution is to do what you suggested and use a style attribute. Tailwind CSS doesn't really deal with dynamic data, but rather with class names to add predefined styles to your element. The best you could without using the style attribute is to conditionally add/remove classNames from an element, but that would require you to know the image URL ahead of time, which defeats the purpose of getting it from an API.

I would do:

    style={{backgroundImage: `url(${fetchedImgSrc})`}}
    

Edit: It looks like you can actually use Tailwind to do something similar to the code above as per [https://tailwindcss.com/docs/background-image](https://tailwindcss.com/docs/background-image). The code looks like:

    <div class="bg-[url('/img/hero-pattern.svg')]">
      
    </div>

you can just use backgroundImage in Style

    const bag2 = "https://via.placeholder.com/500"
    
    <div 
        className = "someting"
        style={{backgroundImage: `url(${bag2})`}}
    
    </div>

Even with the latest implementation of the arbitrary-values - it seems like it's not working for Dynamic URLs. In my case image was coming from an API. If it is the case, stick to style attribute.

In the solution below - bgImage is a prop.

    <div className={`justify-center  bg-no-repeat bg-cover bg-center rounded-lg`} 
    style={{ backgroundImage: `url(${bgImage})`}} >
    
    </div>

How to using dynamic url for background image with tailwindcss react js

在Tailwind CSS中，您可以通过使用预定义的宽度实用类或创建自定义宽度实用类来设置一个元素的宽度为600像素。

1. **使用预定义的宽度实用类（如果存在）：**
   Tailwind CSS 为常用的宽度设置提供了一套预定义的宽度类。但是，在默认配置中，并没有直接对应于600px的宽度类。您可以查看文档或配置文件中的 `theme.width` 部分来确定是否存在适合的预定义宽度。

2. **创建自定义宽度实用类：**
   如果没有预定义宽度匹配600px，您可以在Tailwind的配置文件（`tailwind.config.js`）中扩展默认的宽度设置来添加一个自定义宽度。

```javascript
// tailwind.config.js
module.exports = {
  theme: {
    extend: {
      width: {
        '600': '600px',
      },
    },
  },
  plugins: [],
}
```

这样配置之后，你就可以在HTML中使用 `w-600` 类来将一个元素的宽度设置为600像素了。

```html
<div class="w-600">...</div>
```

当你运行Tailwind CLI工具或者通过构建过程整合Tailwind CSS时，它会生成相应的CSS规则。

请注意，使用自定义值将使您的CSS文件的大小略有增加，因为它会添加额外的类定义。这样做是完全可以接受的，尤其是在项目中确实需要特定像素值的宽度时。

如果您将 Tailwind 安装配置为以即时模式运行，并且运行的是 tailwind 2.1+，则可以使用其任意值支持。[https://tailwindcss.com/docs/just-in-time-mode](https://tailwindcss.com/docs/just-in-time-mode)

例如，我需要 600px 的宽度，我是这样指定的：

`w-[600px]`

您能检查一下下面的代码吗？希望它对你有用。

#1 您需要在 tailwind.config.js 中添加以下代码

    module.exports = {
      theme: {
         extend: {
           width: {
            '600': '600px',
           }
        }
      }
    }
    

#2 之后您可以`w-600`在 HTML 文件中使用，如下所示。

    <div class="w-600">...</div>

您只是缺少括号 \[ \]。尝试这个：

    w-[600px]

看一下大多数 Tailwind 类都有的“任意值”部分。在那里您可以看到如何设置您想要的任何值。

任意值[https://tailwindcss.com/docs/width# Arbitration-values](https://tailwindcss.com/docs/width#arbitrary-values)

> 如果您需要使用一次性宽度值，而该值在主题中包含没有意义，请使用方括号使用任意值动态生成属性。

    <div class="w-[600px]">
      
    </div>

所有问题