我有一个带title属性的anchor元素.我想隐藏在浏览器窗口中将鼠标悬停在其上时出现的弹出窗口.在我的情况下,不可能做这样的事情,
$("a").attr("title", "");
由于jQuery Mobile,标题将在某些事件发生后重新出现(基本上每次重新绘制锚元素时).所以我希望通过CSS隐藏标题.
就像是:
a[title] {
display : none;
}
不起作用,因为它隐藏了整个锚元素.我只想隐藏标题.这甚至可能吗？弹出窗口不应该显示.
前几天,有一个问题,如果有人有一个问题,一个可变引用其中包含借来的数据本身就是一种类型的连接寿命.问题是提供对类型的引用,借用与类型内部借用数据相同的生命周期.我试图重新创建问题:
struct VecRef<'a>(&'a Vec<u8>);
struct VecRefRef<'a>(&'a mut VecRef<'a>);
fn main() {
let v = vec![8u8, 9, 10];
let mut ref_v = VecRef(&v);
create(&mut ref_v);
}
fn create<'b, 'a>(r: &'b mut VecRef<'a>) {
VecRefRef(r);
}
我'b在这里明确注释了create().这不编译:
error[E0623]: lifetime mismatch
--> src/main.rs:12:15
|
11 | fn create<'b, 'a>(r: &'b mut VecRef<'a>) {
| ------------------
| |
| these two types are declared with different lifetimes...
12 | VecRefRef(r);
| ^ ...but data from `r` flows …在Rust 1.3.0中,Deref特征在文档中具有以下签名:
pub trait Deref {
type Target: ?Sized;
fn deref(&'a self) -> &'a Self::Target;
}
我会在没有命名生命期的情况下实现它,因为它们无论如何都会被省略.但是,在docs示例中,它看起来像这样:
use std::ops::Deref;
struct DerefExample<T> {
value: T
}
impl<T> Deref for DerefExample<T> {
type Target = T;
fn deref<'a>(&'a self) -> &'a T {
&self.value
}
}
fn main() {
let x = DerefExample { value: 'a' };
assert_eq!('a', *x);
}
这一切都很好,但是如果我'a在impl而不是方法上指定了lifetime参数:
struct DerefExample<T> {
value: T
}
impl<'a, T> Deref for DerefExample<T> {
type Target = …我的印象是可变引用(即&mut T)总是被移动.这是完全合理的,因为它们允许独占的可变访问.在下面的代码中,我为另一个可变引用分配了一个可变引用,并移动了原始引用.结果我不能再使用原件了:
let mut value = 900;
let r_original = &mut value;
let r_new = r_original;
*r_original; // error: use of moved value *r_original
如果我有这样的功能:
fn make_move(_: &mut i32) {
}
并修改我的原始示例,如下所示:
let mut value = 900;
let r_original = &mut value;
make_move(r_original);
*r_original; // no complain
我期望r_original在make_move用它调用函数时移动可变引用.然而,这不会发生.我仍然可以在通话后使用参考.
如果我使用通用函数make_move_gen:
fn make_move_gen<T>(_: T) {
}
并称之为:
let mut value = 900;
let r_original = &mut value;
make_move_gen(r_original);
*r_original; // error: use of moved …我正在尝试更高级别的特质界限.在我创建的一个最小的例子中,有一个函数采用一个闭包,它接受&str并返回&str相同的生命周期'a.我明确宣布了生命的Fn特征.
fn foo(_: &for<'a> Fn(&'a str) -> &'a str) {
}
fn main() {
foo(&|s| s);
}
这很好用.如果我在闭包中注释参数的类型是类型&str,我收到一个生命周期错误:
fn foo(_: &for<'a> Fn(&'a str) -> &'a str) {
}
fn main() {
foo(&|s: &str| s); // explicitly specified parameter type
}
这让我很困惑.有几个原因.
foo在所有可能的生命周期中都是无法量化的.为什么生命的类型不能随意？是不是
'a只是一辈子的占位符？它没有明确指定类型,但为什么？这两个版本有何不同？
有了这个问题,我正在寻找那些在这方面有更多知识的人的反馈.我绝不是专家.所以我不妨提前问我的问题:我的推理是否正确？
根据这里关于SO 的问题的答案,我很困惑地看到在实施特征方法时终生没有了:
impl<'a, 'b, T> PartialEq<RefEquality<'b, T>> for RefEquality<'a, T> {
fn eq(&self, other: &RefEquality<T>) -> bool {
self.0 as *const T == other.0 as *const T
}
}
这里,在方法签名中,生命周期'b的类型被省略other.这是有效的,也是正确的.我希望它&RefEquality<'b, T>的类型是正确的.毕竟,'b这里必不可少:生命必须与之不同'a.如果没有,那就太限制了:实施只适用于RefEquality<T>生命周期相同的另一个Self.所以这些显然是不同的语义.编译器如何推断出正确的生命周期？
可以省略函数签名的生命周期,但不能在impl块上省略它们.在那里,必须完全指定类型,包括命名生命周期.
eq()另一方面,在方法上,我能够在其他类型注释中忽略生命周期.实际上,编译器然后为它插入一个明显不同的任意生命周期'a.这就是为什么这样做同时保持相同语义的原因:
impl<'a, 'b, T> PartialEq<RefEquality<'b, T>> for RefEquality<'a, T> {
fn eq<'c>(&self, other: &RefEquality<'c, T>) -> bool {
self.0 as *const T == other.0 as …该错误处理章锈书包含有关如何使用的组合子的例子Option和Result。读取文件并通过应用一系列组合器将内容解析为i32并以Result<i32, String>. 现在，当我查看代码时，我感到困惑。在那里，在一个 and_then 的闭包中，String创建了一个局部值，随后作为返回值传递给另一个组合器。
下面是代码示例：
use std::fs::File;
use std::io::Read;
use std::path::Path;
fn file_double<P: AsRef<Path>>(file_path: P) -> Result<i32, String> {
File::open(file_path)
.map_err(|err| err.to_string())
.and_then(|mut file| {
let mut contents = String::new(); // local value
file.read_to_string(&mut contents)
.map_err(|err| err.to_string())
.map(|_| contents) // moved without 'move'
})
.and_then(|contents| {
contents.trim().parse::<i32>()
.map_err(|err| err.to_string())
})
.map(|n| 2 * n)
}
fn main() {
match file_double("foobar") {
Ok(n) => println!("{}", n),
Err(err) => …在玩零尺寸类型(ZST)时,我遇到了一个有趣的案例.对空数组的引用将模拟到任何生命周期的引用:
fn mold_slice<'a, T>(_: &'a T) -> &'a [T] {
&[]
}
我想到了这是怎么可能的,因为这里的"值"基本上存在于函数的堆栈框架中,但签名承诺返回对具有更长生命周期的值的引用('a包含函数调用).我得出的结论是,因为空数组[]是一个ZST,它基本上只是静态存在.编译器可以"伪造"引用所引用的值.
所以我尝试了这个:
fn mold_unit<'a, T>(_: &'a T) -> &'a () {
&()
}
然后编译器抱怨:
error: borrowed value does not live long enough
--> <anon>:7:6
|
7 | &()
| ^^ temporary value created here
8 | }
| - temporary value only lives until here
|
note: borrowed value must be valid for the lifetime 'a as defined on the block at 6:40...
--> …我有这段代码:
#[derive(Debug)]
struct Foo<'a> {
x: &'a i32,
}
impl<'a> Foo<'a> {
fn set(&mut self, r: &'a i32) {
self.x = r;
}
}
fn main() {
let v = 5;
let w = 7;
let mut f = Foo { x: &v };
println!("f is {:?}", f);
f.set(&w);
println!("now f is {:?}", f);
}
我的理解是,在第一次借用值时v,'astruct声明中的泛型生命周期参数将填充值的生命周期v.这意味着生成的Foo对象的'a寿命不得超过此生命周期,或者v必须至少与Foo对象一样长.
在对方法的调用中set,impl使用块上的生命周期参数,并在方法签名中w填充值的生命周期'a …
我正在尝试实现Iterator一个结构的特征,该结构充当i32值数组的借用者,但我一直在运行编译器抱怨无法在下一个方法中推断出生命周期.
我知道需要帮助理解迭代器的生命周期,但是因为我的结构只是借用了数组的一部分,所以我将实际元素的记忆与我的分开IntegerArrayBag.
#[derive(Debug)]
struct IntegerArrayBag<'a> {
arr: &'a [i32],
idx: usize,
}
impl<'a> IntegerArrayBag<'a> {
fn len(&self) -> usize {
self.arr.len()
}
fn get(&self, idx: usize) -> Option<&i32> {
if self.arr.len() > idx {
Some(&self.arr[idx])
} else {
None
}
}
}
impl<'a> Iterator for IntegerArrayBag<'a> {
type Item = &'a i32;
fn next(&mut self) -> Option<&'a i32> {
let idx = self.idx;
self.idx += 1;
self.get(idx)
}
}
如果我尝试编译此代码,编译器会抱怨: …