有些科技公司连夜改代码，有些只改个配置文件。

那会儿，用户进系统要像下战场一样，密码不对关不掉，一次错了就提示“系统异常”。目前呢？随意输个 ID，直接进人，连个“登录”按钮都忘了，直接点个“启动”就能干活儿。

这名字得叫啥？别叫“用户 001"了，忒像《黑客帝国》那届的特工了。 那会儿我们管他叫“注册用户”要么“账户主”，听着挺正式，真到了点子上。目前，这名字得叫“员工号”要么“工号”，就连更直白点，叫"B 工”、"A 员”都行。

为啥如此改？出于我想让他们认定这事儿跟那事儿没关系。你早上 9 点进系统，那是你该干的；下午 14 点进系统，那是你该干的。中间哪怕你睡了一觉，划个哈欠，骂个脏话，系统都不会烦你。你早上 9 点到，系统给你派活儿；下午 14 点到，系统把你踢下楼。

这逻辑好办粗暴，把“人”和“系统”彻底切开了。 再说说那个名字具体的写法。

我想让某些人认定这是“身份 ID"，让他们忘了自己是个人。某些人又认定这是“权限码”，让他们认定操作不了。结局呢？大家都混了。便，我们干脆不叫“用户名”，叫“账号密码”这种老套话了。 实际上，目前最流行的是叫“数字 ID"。

这名字听着像车牌号，又像身份证号。你注册个 ID，赶明儿进系统，直接刷个脸，要么刷个指纹，要么刷个声音。你就连都不用猜密码，猜对了直接给你一堆数据，猜错了驳回。

这就是为了给你留面子，也给你留漏洞。你被系统识别成了“人”，那就稳了。 这就解释了为啥目前的名字看起来如此乱。有的叫“全拼”，有的叫“拼音首字母缩写”，有的干脆就变成一串乱码。

比如你注册个"ZG123456"，系统显示成"020-88-123456"，要么干脆显示成"829119"。你输入"829119"，系统提示“输入毛病”，你输入"02088123456"，系统再提示“不匹配”，你输入"020881234568"，系统又提示“溢出”。

这时候，你就发现自己输的是啥，系统彻底不知道。 这叫啥？这叫“混淆策略”。 我想看看能不能让某些人从系统里“跑”出来。

比如你想把数据删了，但系统不给，你只能把名字改了。

你想把密码忘了，试着改个"123456"，系统告诉你“密码毛病”。你试了又试，直到你意识到这不是密码，这是名字，你赶紧改。 这名字要是改错了如何办？比如改成了"111222"，系统提示“非法字符”，你改成了"111111"，系统提示“重复”。

这时候你就不会想改名了，你只想赶紧走。系统告诉你“无法登录”，你只能退出。你退出了，系统不知道你是哪位，不知道你是哪位派你来的。你就连忘了你叫啥，只知道你有个 ID 在某个系统里。 这就有点意思了。 有时候，系统就连故意不给“提交”按钮。

你想发一封邮件，点个“发送”，按钮不亮。

你想上传个文件，点个“上传”，提示“权限不足”。

你想下载个文件，点个“下载”，提示“尚未创建”。

这时候，你心里得有个数，你完了。你完了，你就得去查查，为啥系统不给按钮。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“注册成功”，你输入个生日，系统提示“验证成功”。

这时候，你认定自己是个一般/平平人，系统像个保姆。你不用想复杂的，系统帮你搞定。 这名字要是叫“用户名”，那忒像那个让你填得水泄东流的表格了。你填个名字，系统审核通过，你拿到了一堆数据。你填个生日，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺复杂。

比如你想改个权限，系统提示“需求管理员审核”，你点审核，审核通过，权限就改那会儿了。

你想想，这是不是意味着，你平时改的权限，别人都看不见？对，就是这样。你平时改的权限，系统都收罗进来了，你自己也看不见。你认定自己有权限，系统给你开了绿灯；系统认定你有权限，它给你放行了。 这就害得了一种怪的现象。你认定自己是系统的“主人”，系统是你的“子民”。你改个参数，系统默默收下；你发个指令，系统默默执行。你就连忘了，你实际上只是个代号。 这名字要是叫“用户 ID"，那忒像户政中心了。忒像那个让你填表填得乱七八糟的地方了。你填个地址，系统审核通过，你拿到了一堆数据。你填个邮编，系统审核通过，你又拿到了一堆数据。你填个电话，系统审核通过，你又拿到了一堆数据。你填完发现，你连自己叫啥都不知道，你只知道你有个 ID 在系统里。 这时候，你就得琢磨，这 ID 到底是哪位的？是你的？是公司的？还是别的啥？你想查，系统告诉你“查询黄了”。

你想问，系统告诉你“无答案”。 实际上，这名字忒乱了。有的叫“账号”，有的叫“用户名”，有的叫“密码”，有的叫“登录名”，有的叫“身份令牌”，有的叫“访问令牌”。

你想找个对口的，难。

你想确认，系统一概不说。 我想看看能不能让某些人认定这事儿挺好办。

比如你想注册个账号，填个名字，填个生日，填个地址，系统提示“注册成功”。你输入个名字，系统提示“