Como o JavaScript percebe que os tipos básicos possuem propriedades e métodos como os objetos?

[Recomendações relacionadas: tutoriais em vídeo de JavaScript, front-end da web]

"Métodos de atributos" de tipos básicos

Este artigo explorará um conceito extremamente interessante, ou seja, os métodos de atributos de tipos básicos. Que tal, você está um pouco confuso? Deixe-me contar lentamente ~

Prefácio

Em outras linguagens de programação orientadas a objetos, como Java e C++ , atributos são um conceito único de objetos, e o tipo básico é o tipo básico. Não existe conceito de métodos de atributos.

Sim, é outra má ideia de JavaScript . Seu mecanismo nos permite usar métodos de propriedade para manipular tipos básicos de dados, como objetos.

Antes de explicar esse estranho recurso, devemos primeiro esclarecer qual é a diferença entre tipos básicos e tipos de objetos.

O que
1. • { }
2. um tipo básico
   • ? Um dos tipos básicos de JavaScript .
   • Existem 7 tipos básicos em JavaScript , a saber: String , Number , Boolean , BigInt , Symbol , null e undefined .
3. • { } Criar e armazenar vários valores;
   • JavaScript também possui outros tipos de objetos, como funções, que

serão abordados na orientação a objetos. Um recurso importante na introdução de objetos é o encapsulamento , que pode armazenar todos os tipos de dados e métodos confusos em um. object , reduzindo assim a complexidade de uso.

Por exemplo:

deixe usuário = {
    nome: "xiaoming",
    olá() {
        console.log(`Olá, meu nome é ${this.name}`);
    }}user.hello();

Encapsulamos os atributos e métodos do objeto user em um objeto, para que seja muito simples de usar. Só precisamos usar obj.attr para chamar métodos ou atributos.

No entanto, fazer isso envolve sobrecarga adicional (orientada a objetos tem sobrecarga adicional), que também é onde a linguagem orientada a objetos C++ é mais lenta que C

Problemas enfrentados

ao usar tipos básicos

como objetos Existem dois problemas que são difíceis de conciliar ao usar tipos básicos como objetos:

1. esperamos que as operações em tipos básicos possam ser as mesmas que usar objetos, como "abc".toUpperCase() ;
2. objetos têm sobrecarga adicional, também esperamos manter as características simples e eficientes do tipo básico,

a solução é que

JavaScript resolva os problemas acima de uma forma muito "simples":

1. o tipo básico é o tipo básico, fornecendo um tipo independente, valor único
2. permitindo acesso a métodos e propriedades do tipo String , Number , Boolean e Symbol
3. para garantir a completude da teoria, ao utilizar os métodos e propriedades do tipo básico, eles são primeiro empacotados em objetos e depois destruídos; ;

o significado das regras acima é que o tipo básico ainda é um tipo básico, mas e se quisermos acessar os métodos e propriedades de um tipo básico, agruparemos o tipo básico em um objeto (invólucro de objeto) e então destrua-o após a conclusão do acesso. Para ser honesto, parece um pouco ridículo.

Um exemplo

dos eventos por trás disso

let name = "Trump";console.log(name.toUpperCase());//Métodos para acessar os tipos básicos

Os resultados da execução do código acima são os seguintes:

Parece que não há grande problema, mas muitas coisas aconteceram, e precisamos saber os seguintes pontos:

1. name é um tipo básico de string, e não há nada de especial nisso
2. ao acessar name , um arquivo que contém
;
3. Um objeto especial com um valor de string. Este objeto possui um método toUpperCase
que chama o método toUpperCase do objeto especial
4. e
5. toUpperCase uma nova string

;

O resultado do compromisso

Embora a solução esteja cheia de compromissos (más ideias), o resultado ainda é bom, e as conquistas alcançadas são as seguintes:

1. o tipo básico mantém sua simplicidade e eficiência
2. o tipo básico possui propriedades e métodos por meio de objetos especiais; ;
3. o completo teórico, ou seja, apenas objetos possuem propriedades e métodos,

embora isso seja teoricamente verdade, na verdade o mecanismo JavaScript é altamente otimizado para esse processo e suspeito que ele não cria nenhum objeto adicional; Ele apenas afirmou verbalmente que seguiu as regras, como se realmente tivesse um objeto temporário.

Exemplos de métodos comumente usados

​​Este artigo apresenta apenas brevemente o conceito de métodos de tipo básico e não explica vários métodos. À medida que o tutorial continua a se aprofundar, um grande número de métodos será gradualmente envolvido. Aqui listamos apenas brevemente alguns métodos e propriedades comumente usados ​​de tipos básicos.

Diferentes tipos básicos têm diferentes métodos de atributos, listados nas seguintes categorias:

1. Atributo

   length

   comprimento

de string

1. 

2. indexOf(ch) retorna o subscrito do primeiro caractere ch na string

   console.log("abc".indexOf('b'));console.log("abc".indexOf('d'))

   ; os resultados da execução do código são os seguintes:

   

   Quando o caractere existe na string, o índice (contado a partir de 0 ) é retornado, caso não seja encontrado, -1 é retornado.

3. método concat(str) , unir duas strings

   let str1 = "hello ";let str2 = "world!";console.log(str1.concat(str2));console.log(str1);console.log(str2 );

   Os resultados da execução do código são os seguintes:

   

4. método replace(str1,str2) , use str2 para substituir str1

   let str = "javascript";console.log(str.replace('java','996'));

   console.log

   (str);

   do seguinte modo:

   

Number

1. toFixed(num) , arredondando decimais para a precisão especificada

   console.log(9.3333333.toFixed(3)); console.log(9.3333333.toFixed(0))

   ;

   

2. Método toString() , converte números em strings

   3.14.toString();//Converter para '3.14'console.log((8).toString(2));//Converter para binário '1000'console.log((( 9).toString(2));//Converter para binário '1001'console.log((996).toString(16));//Converter para string hexadecimal '3e4'Os

   resultados da execução do código são os seguintes:

   

3. Método

   toExponential() , convertido em método de contagem exponencial

   console.log(3.1415926.toExponential());

   do seguinte modo:

   

Mais métodos serão mostrados nos capítulos subsequentes, por isso não entrarei em detalhes aqui.

Construtor de tipo básico (recurso obsoleto)

Como Java , JavaScript pode criar explicitamente "wrappers de objetos" para tipos básicos por meio do operador new . Essa abordagem é extremamente desencorajada .

Existem problemas com esta abordagem, por exemplo:

typeof

0);

Ou haverá confusão no julgamento:

let zero = new Number(0);if (zero) { // zero é verdadeiro porque é um objeto console.log('true');}

O resultado da execução do código é como segue:

Ao mesmo tempo, não se esqueça que a função String/Number/Boolean sem new (palavra-chave) pode converter um valor para o tipo correspondente: em uma string, um número ou um valor booleano (tipo original).

Por exemplo:

console.log(typeof Number('123'));

Nota:

Os dois tipos null e undefined não possuem nenhum método

nesta seção,

1. JavaScript

2. tipos básicos diferentes de null e undefined fornecem muitos métodos úteis;

3. um método de implementação comprometido, mas obteve resultados relativamente satisfatórios, realizando os atributos e chamadas de métodos de tipos básicos a um custo menor

[Recomendações relacionadas: tutoriais em vídeo de JavaScript, front-end da web]

A descrição acima é como o JavaScript percebe que os tipos básicos têm o mesmo; atributos e objetos como objetos Para obter detalhes do método, preste atenção a outros artigos relacionados na rede de código-fonte para obter mais informações!