在本文中，我们将详细介绍使用ObjectIdentifier的各个方面，并为您提供关于和'==='运算符之间的区别的相关解答，同时，我们也将为您带来关于adifferentobjectwiththes

在本文中，我们将详细介绍使用ObjectIdentifier的各个方面，并为您提供关于和'==='运算符之间的区别的相关解答，同时，我们也将为您带来关于a different object with the same identifier val...、actionscript-3 – Object和*之间的区别？、angular – 无法解析AuthenticationService的所有参数：([object Object],？,[object Object])、Beautifulsoup：.find（）和.select（）之间的区别的有用知识。

• 使用ObjectIdentifier（）和'==='运算符之间的区别（object.is()用法）
• a different object with the same identifier val...
• actionscript-3 – Object和*之间的区别？
• angular – 无法解析AuthenticationService的所有参数：([object Object],？,[object Object])
• Beautifulsoup：.find（）和.select（）之间的区别

使用ObjectIdentifier（）和'==='运算符之间的区别（object.is()用法）

假设我正在Swift中实现一个根类，我声明该根类采用了Equatable协议（我希望能够知道我类型的数组是否包含给定的实例）。

*在此特定情况下，将协议的所需==运算符实现为之间有 *什么区别（ 如果有的话）：

public static func ==(lhs: MyClass, rhs: MyClass) -> Bool {    return ObjectIdentifier(lhs) == ObjectIdentifier(rhs)}

…而不是仅仅这样做：

public static func ==(lhs: MyClass, rhs: MyClass) -> Bool {    return (lhs === rhs)}

作为参考，这是文档中所说的ObjectIdentifier()：

类实例或元类型的唯一标识符。在Swift中，只有类实例和元类型才具有唯一标识。对于结构，枚举，函数或元组，没有身份的概念。

......这是什么的“基本算法”一节雨燕编程语言（斯威夫特3）表示，有关===操作：

注意

Swift还提供了两个标识运算符（===和!==），用于测试两个对象引用是否都引用同一对象实例。有关更多信息，请参见类和结构。

答案1

类实例没有区别，请参见ObjectIdentifier.swift中的以下
注释：

  /// Creates an instance that uniquely identifies the given class instance.  ///  /// The following example creates an example class `A` and compares instances  /// of the class using their object identifiers and the identical-to  /// operator (`===`):  ///  ///     class IntegerRef {  ///         let value: Int  ///         init(_ value: Int) {  ///             self.value = value  ///         }  ///     }  ///  ///     let x = IntegerRef(10)  ///     let y = x  ///  ///     print(ObjectIdentifier(x) == ObjectIdentifier(y))  ///     // Prints "true"  ///     print(x === y)  ///     // Prints "true"  ///  ///     let z = IntegerRef(10)  ///     print(ObjectIdentifier(x) == ObjectIdentifier(z))  ///     // Prints "false"  ///     print(x === z)  ///     // Prints "false"  ///

从for的实现中==``ObjectIdentifier也可以明显看出，该
实现只比较指向对象存储的指针：

  public static func == (x: ObjectIdentifier, y: ObjectIdentifier) -> Bool {    return Bool(Builtin.cmp_eq_RawPointer(x._value, y._value))  }

这正是该===操作
确实还有：

public func === (lhs: AnyObject?, rhs: AnyObject?) -> Bool {  switch (lhs, rhs) {  case let (l?, r?):    return Bool(Builtin.cmp_eq_RawPointer(        Builtin.bridgeToRawPointer(Builtin.castToUnknownObject(l)),        Builtin.bridgeToRawPointer(Builtin.castToUnknownObject(r))      ))  case (nil, nil):    return true  default:    return false  }}

ObjectIdentifier符合Hashable，因此如果要为您的类实现该协议，将非常有用：

extension MyClass: Hashable {    var hashValue: Int {        return ObjectIdentifier(self).hashValue    }}

还可以为未定义的元类型（例如ObjectIdentifier(Float.self)）创建对象标识符===。

a different object with the same identifier val...

actionscript-3 – Object和*之间的区别？

private var someVar:*;

private var someVar:Object;

angular – 无法解析AuthenticationService的所有参数：([object Object],？,[object Object])

@Inject(forwardRef(() => AuthenticationService)) public authService: AuthenticationService

import { Injectable } from '@angular/core';
import {Http,Headers,Response} from '@angular/http';
import 'rxjs/add/operator/toPromise';
import {Observable} from 'rxjs/Rx';

import {AppServices} from "../../app.services";
import {Router} from "@angular/router";

@Injectable()
export class AuthenticationService {
  public token: any;

  constructor(
    private http: Http,private appService: AppServices,private router: Router
  ) {
    this.token = localStorage.getItem('token');
  }

  login(username: string,password: string): Observable<boolean> {
    let headers = new Headers();
    let body = null;
    headers.append("Authorization",("Basic " + btoa(username + ':' + password)));

    return this.http.post(this.appService.api + '/login',body,{headers: headers})
      .map((response: Response) => {
        let token = response.json() && response.json().token;
        if (token) {
          this.token = token;
          localStorage.setItem('Conform_token',token);
          return true;
        } else {
          return false;
        }
      });
  }

  logout(): void {
    this.token = null;
    localStorage.removeItem('Conform_token');
    this.router.navigate(['/login']);
  }
}

import {Injectable} from '@angular/core';
import {Headers,Http,RequestOptions} from '@angular/http';
import {Router} from "@angular/router";
import {AuthenticationService} from "./auth/auth.service";

import 'rxjs/add/operator/toPromise';
import {Observable} from 'rxjs/Rx';

@Injectable()

export class AppServices {

  api = '//endpoint/';

  public options: any;
  constructor(
    private http: Http,private router: Router,public authService: AuthenticationService // doesn't work
  //  @Inject(forwardRef(() => AuthenticationService)) public authService: AuthenticationService // doesn't work either
      ) {
        let head = new Headers({
      'Authorization': 'Bearer ' + this.authService.token,"Content-Type": "application/json; charset=utf8"
    });
    this.options = new RequestOptions({headers: head});
  }

  // ====================
  //    data services
  // ====================

  getData(): Promise<any> {
    return this.http
      .get(this.api + "/data",this.options)
      .toPromise()
      .then(response => response.json() as Array<Object>)
      .catch((err)=>{this.handleError(err);})
  }

import { browserModule } from '@angular/platform-browser';
import { browserAnimationsModule } from '@angular/platform-browser/animations';

import { NgModule } from '@angular/core';
import { FormsModule } from '@angular/forms';
import {BaseRequestOptions,HttpModule} from '@angular/http';

import { MaterialModule} from '@angular/material';
import {FlexLayoutModule} from "@angular/flex-layout";
import 'hammerjs';

import { routing,appRoutingProviders }  from './app.routing';
import { AppServices } from './app.services';
import {AuthGuard} from "./auth/auth.guard";
import {AuthenticationService} from "./auth/auth.service";

import {AppComponent} from './app.component';
import {AuthComponent} from './auth/auth.component';
import {NotFoundComponent} from './404/not-found.component';
import { HomeComponent } from './home/home.component';

@NgModule({
  declarations: [
    AppComponent,AuthComponent,NotFoundComponent,HomeComponent
  ],imports: [
    browserModule,browserAnimationsModule,FormsModule,HttpModule,routing,MaterialModule,FlexLayoutModule
  ],providers: [AppServices,AuthGuard,AuthenticationService],bootstrap: [AppComponent]
})
export class AppModule { }

export class AuthenticationService {
  public token: any;
  appService: AppServices;
  constructor(
    private http: Http,// private appService: AppServices,injector:Injector;
    private router: Router
  ) {
    setTimeout(() => this.appService = injector.get(AppServices));
    this.token = localStorage.getItem('token');
  }

Beautifulsoup：.find（）和.select（）之间的区别

当您使用
BeautifulSoup
抓取网站的特定部分时，您可以使用

• soup.find()和soup.findAll()或
• soup.select()。

.find()和.select()方法之间有区别吗？（例如，性能或灵活性等）还是相同？

答案1

总结评论：

• select 查找多个实例并返回一个列表， find 查找第一个实例，因此它们不会执行相同的操作。 select_one 将等同于 find 。
• 我链接时，标签或使用几乎总是使用CSS选择 tag.classname ，如果寻找一个单一的元素没有一个类我用 找到 。本质上，它取决于用例和个人喜好。
• 就灵活性而言，我认为您知道答案，soup.select("div[id=foo] > div > div > div[class=fee] > span > span > a")使用多个链接的 find / find_all 调用看起来很难看。
• bs4中的css选择器唯一的问题是对它的支持非常有限， nth-of-type 是唯一实现的伪类，并且像c [sref ]的许多其他部分一样，也不支持链接属性，例如a [href] [src]。但是像 a [href = ..] *， a [href ^ =] ， a [href $ =] 等之类的东西我认为要好得多，find("a", href=re.compile(....))但这又是个人喜好。

为了提高性能，我们可以运行一些测试，我修改了此处答案的代码，该答案在从此处获取的800多个html文件上运行，虽然并不详尽，但应为某些选项的可读性和性能提供线索：

修改后的功能为：

from bs4 import BeautifulSoupfrom glob import iglobdef parse_find(soup):    author = soup.find("h4", class_="h12 talk-link__speaker").text    title = soup.find("h4", class_="h9 m5").text    date = soup.find("span", class_="meta__val").text.strip()    soup.find("footer",class_="footer").find_previous("data", {        "class": "talk-transcript__para__time"}).text.split(":")    soup.find_all("span",class_="talk-transcript__fragment")def parse_select(soup):    author = soup.select_one("h4.h12.talk-link__speaker").text    title = soup.select_one("h4.h9.m5").text    date = soup.select_one("span.meta__val").text.strip()    soup.select_one("footer.footer").find_previous("data", {        "class": "talk-transcript__para__time"}).text    soup.select("span.talk-transcript__fragment")def  test(patt, func):    for html in iglob(patt):        with open(html) as f:            func(BeautifulSoup(f, "lxml")

现在是时候了：

In [7]: from testing import test, parse_find, parse_selectIn [8]: timeit test("./talks/*.html",parse_find)1 loops, best of 3: 51.9 s per loopIn [9]: timeit test("./talks/*.html",parse_select)1 loops, best of 3: 32.7 s per loop

就像我说的并不详尽，但我认为我们可以肯定地说CSS选择器绝对有效。

今天关于使用ObjectIdentifier和和'==='运算符之间的区别的分享就到这里，希望大家有所收获，若想了解更多关于a different object with the same identifier val...、actionscript-3 – Object和*之间的区别？、angular – 无法解析AuthenticationService的所有参数：([object Object],？,[object Object])、Beautifulsoup：.find（）和.select（）之间的区别等相关知识，可以在本站进行查询。