StyleSheet.create och inline-stilar
Skapa stilobjekt med StyleSheet.create för bättre prestanda, jämför dem med inline-stilar och använd flera stilar med hjälp av arrayer.
StyleSheet.create och inline-stilar är en gratis lektion i React Native Academy på CoddyKit. Detta är lektion 1 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för React Native Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i React Native Academy innehåller totalt 4 lektioner.
Så fungerar stilar i React Native
Styling i React Native är inspirerad av CSS, men använder JavaScript-objekt i stället för CSS-filer. Egenskapsnamn skrivs i camelCase (backgroundColor i stället för background-color), och värden för längder och storlekar är tal som representerar enhetsoberoende pixlar – inte strängar som '16px'. Det finns inga selektorer, ingen kaskad och inget arv (förutom typsnittsstilar i nästlade Text-komponenter). Varje komponent stylas individuellt via en style-prop, vilket ger dig uttrycklig kontroll över varje elements utseende.
import { View, Text } from 'react-native';
export default function StyledBox() {
return (
// Inline style object directly
<View style={{
width: 120,
height: 120,
backgroundColor: '#4f86f7',
borderRadius: 16,
padding: 16,
}}>
<Text style={{ color: '#fff', fontSize: 18, fontWeight: 'bold' }}>
Hello!
</Text>
</View>
);
}StyleSheet.create() för bättre prestanda
StyleSheet.create() tar ett objekt med namngivna stildefinitioner och returnerar en bearbetad version. Under huven registrerar React Native dessa stilar i det inbyggda lagret och skickar endast ett heltals-ID vid efterföljande renderingar, i stället för hela stilobjektet. Det minskar kostnaden för kommunikationen mellan JavaScript och det inbyggda lagret – särskilt märkbart i listor som renderas om ofta. I utvecklingsläge valideras även stilarna, och du får en varning om du använder egenskaper som inte stöds. Föredra alltid StyleSheet.create framför inline-objekt för stilar som inte ändras.
import { View, Text, StyleSheet } from 'react-native';
export default function Card() {
return (
<View style={styles.card}>
<Text style={styles.title}>Card Title</Text>
<Text style={styles.body}>Card description text goes here.</Text>
</View>
);
}
// Defined once, referenced by name
const styles = StyleSheet.create({
card: {
backgroundColor: '#fff',
borderRadius: 12,
padding: 16,
marginBottom: 12,
elevation: 3,
},
title: { fontSize: 18, fontWeight: 'bold', color: '#222' },
body: { fontSize: 14, color: '#666', marginTop: 6, lineHeight: 20 },
});Inline-stilar: när ska de användas
Inline-stilar skrivs direkt i JSX som en JavaScript-objektliteral: style={{ color: 'red' }}. De skapas om vid varje rendering, vilket är något mindre effektivt än stilar från StyleSheet.create. Inline-stilar passar däremot när stilvärdet är dynamiskt – alltså beräknas från props eller tillstånd vid körning. Du kan till exempel ange backgroundColor utifrån användarens valda temafärg eller beräkna width från komponentens aktuella tillstånd. I dessa fall kan StyleSheet.create inte hjälpa, eftersom värdet ändras vid körning.
import { View } from 'react-native';
// Inline style: backgroundColor is dynamic (from props)
function ColoredBox({ color, size }) {
return (
<View
style={{
backgroundColor: color, // dynamic — must be inline
width: size, // dynamic — must be inline
height: size,
borderRadius: size / 2,
}}
/>
);
}
// Usage:
<ColoredBox color='#ff6b6b' size={80} />
<ColoredBox color='#4f86f7' size={40} />Kombinera statiska och dynamiska stilar
React Natives style-prop accepterar en array med stilobjekt. Senare stilar i arrayen skriver över tidigare stilar för samma egenskap (ungefär som specificitet i CSS, men enklare). På så sätt kan du kombinera en grundstil från StyleSheet.create med dynamiska inline-överskrivningar: style={[styles.box, { backgroundColor: color }]}. De statiska stilarna är effektiva eftersom endast ID:n skickas, medan det dynamiska inline-objektet läggs ovanpå. Falsy-värden i arrayen (null, undefined, false) ignoreras säkert.
import { TouchableOpacity, Text, StyleSheet } from 'react-native';
export default function Button({ label, primary, style }) {
return (
<TouchableOpacity
style={[
styles.base, // always applied
primary && styles.primary, // conditional style
style, // caller's overrides
]}
>
<Text style={[styles.text, primary && styles.primaryText]}>
{label}
</Text>
</TouchableOpacity>
);
}
const styles = StyleSheet.create({
base: { paddingVertical: 12, paddingHorizontal: 24, borderRadius: 24, borderWidth: 1.5, borderColor: '#4f86f7', alignItems: 'center' },
primary: { backgroundColor: '#4f86f7', borderColor: '#4f86f7' },
text: { color: '#4f86f7', fontWeight: '600', fontSize: 16 },
primaryText: { color: '#fff' },
});Vanliga StyleSheet-egenskaper
I den här lektionen lärde Ni Er: StyleSheet.create är effektivare än infogade objekt eftersom stilar skickas som ID:n och inte som fullständiga objekt, stilarrayer slår samman flera stilobjekt där senare poster har företräde, och useColorScheme möjliggör stilar som anpassas efter mörkt läge. Härnäst utforskar vi Flexbox-riktning, justifyContent och alignItems för full kontroll över layouten.
const styles = StyleSheet.create({
// Layout
container: { flex: 1, flexDirection: 'column', justifyContent: 'center', alignItems: 'center' },
// Box model
box: { width: 100, height: 100, margin: 8, padding: 12 },
// Visual
card: { backgroundColor: '#fff', borderRadius: 12, opacity: 0.9, zIndex: 10 },
// Borders
bordered: { borderWidth: 1, borderColor: '#ccc', borderStyle: 'solid' },
// Text styles (only valid on Text component)
heading: { fontSize: 24, fontWeight: '700', color: '#333', letterSpacing: 0.5 },
});Procentvärden i stilar
React Native stöder procentsträngar för width, height och positioneringsegenskaper som top och left. En bredd på '100%' fyller hela den överordnade komponenten, '50%' tar upp hälften, och så vidare. Procentvärden beräknas i förhållande till den överordnade containerns storlek, inte skärmen. Detta är användbart för kort som ska ta upp hela bredden (width: '100%') och layouter med två kolumner (width: '48%'). För själva skärmbredden använder Ni Dimensions-API:t eller hooken useWindowDimensions för responsiva, dynamiska värden.
import { View, useWindowDimensions, StyleSheet } from 'react-native';
export default function HalfBox() {
const { width } = useWindowDimensions();
const cardWidth = (width - 48) / 2; // two columns with gutters
return (
<View style={styles.row}>
<View style={[styles.card, { width: cardWidth }]} />
<View style={[styles.card, { width: cardWidth }]} />
</View>
);
}
const styles = StyleSheet.create({
row: { flexDirection: 'row', gap: 16, paddingHorizontal: 16 },
card: { height: 100, backgroundColor: '#4f86f7', borderRadius: 12 },
});StyleSheet.flatten och sammanslagning av stilar
StyleSheet.flatten() tar emot en stilarray och returnerar ett enda sammanslaget objekt. Detta är användbart när Ni programmatiskt behöver läsa det slutliga beräknade stilvärdet — till exempel läsa backgroundColor från en stilarray för att skicka det till en animering. Stilarrayer löses på samma sätt som i React Native: senare värden skriver över tidigare. Att logga StyleSheet.flatten(styles) är också praktiskt vid felsökning, eftersom Ni då ser exakt vilka stilar en komponent får efter att all sammanslagning har gjorts.
import { StyleSheet } from 'react-native';
const base = StyleSheet.create({
box: { width: 100, height: 100, backgroundColor: 'blue' },
});
const override = { backgroundColor: 'red', borderRadius: 12 };
// Merge and inspect the final style
const final = StyleSheet.flatten([base.box, override]);
console.log(final);
// {
// width: 100,
// height: 100,
// backgroundColor: 'red', ← override wins
// borderRadius: 12 ← new property added
// }StyleSheet.hairlineWidth
StyleSheet.hairlineWidth returnerar den tunnaste möjliga linjebredden på den aktuella enheten — vanligtvis 0.5 på Retina-skärmar och 1 på skärmar med lägre pixeltäthet. Använd den för tunna avdelare och kantlinjer som ska se skarpa ut oavsett pixeltäthet. Den är bättre än att hårdkoda borderWidth: 0.5, eftersom hairlineWidth automatiskt anpassar sig efter skärmens pixelförhållande. Det är en liten men märkbar detalj som ger en mer genomarbetad känsla på skärmar med hög pixeltäthet, som i moderna iPhone- och Pixel-enheter.
import { View, StyleSheet } from 'react-native';
// A 1-physical-pixel divider line
export default function Divider() {
return <View style={styles.divider} />;
}
const styles = StyleSheet.create({
divider: {
height: StyleSheet.hairlineWidth, // thinnest possible
backgroundColor: '#e0e0e0',
marginVertical: 8,
},
});
// StyleSheet.hairlineWidth value:
// Retina (2× pixel ratio) → 0.5
// 3× pixel ratio → 0.333...
// 1× screen → 1Samplacering av stilar med komponenter
En vanlig konvention är att definiera stilar längst ned i samma fil som komponenten som använder dem. Då hålls relaterad kod samlad, och det blir enkelt att förstå en komponents fullständiga visuella specifikation utan att öppna en annan fil. För mycket stora komponenter med många stilavsnitt kan Ni dela upp stilarna i en separat fil med namnet ComponentName.styles.ts. Undvik att skapa en enda global fil med namnet styles.js för hela appen — den blir svår att hantera och gör det svårt att veta var de olika stilarna används.
// ProfileCard.tsx
import { View, Text, StyleSheet } from 'react-native';
export default function ProfileCard({ name, bio }) {
return (
<View style={styles.card}>
<Text style={styles.name}>{name}</Text>
<Text style={styles.bio}>{bio}</Text>
</View>
);
}
// Styles defined at the bottom of the same file
const styles = StyleSheet.create({
card: { backgroundColor: '#fff', borderRadius: 16, padding: 20 },
name: { fontSize: 20, fontWeight: 'bold', color: '#111' },
bio: { fontSize: 14, color: '#555', marginTop: 6, lineHeight: 20 },
});Stilar som tar hänsyn till mörkt läge
För att stödja mörkt läge använder Ni hooken useColorScheme för att identifiera det aktuella schemat ('light' eller 'dark') och väljer sedan olika färgvärden för varje läge. Kombinera detta med Er stilarray: basstilarna innehåller layout och form, medan ett dynamiskt färgobjekt tillämpar temats färger. En mer skalbar metod är en ThemeContext som tillhandahåller färgtokens i hela appen, men useColorScheme är det snabbaste sättet att få mörkt läge att fungera utan ytterligare bibliotek.
import { View, Text, StyleSheet, useColorScheme } from 'react-native';
export default function ThemedCard({ title }) {
const scheme = useColorScheme(); // 'light' | 'dark'
const colors = scheme === 'dark'
? { bg: '#1c1c1e', text: '#f0f0f0', border: '#3a3a3c' }
: { bg: '#ffffff', text: '#111111', border: '#e0e0e0' };
return (
<View style={[styles.card, { backgroundColor: colors.bg, borderColor: colors.border }]}>
<Text style={[styles.title, { color: colors.text }]}>{title}</Text>
</View>
);
}
const styles = StyleSheet.create({
card: { borderWidth: 1, borderRadius: 12, padding: 16, marginBottom: 12 },
title: { fontSize: 18, fontWeight: '600' },
});Styled Components i React Native
Om Ni föredrar en CSS-in-JS-syntax fungerar styled-components med React Native. Installera det med npm install styled-components och använd fabrikerna styled.View och styled.Text. Styled-components genererar optimerade StyleSheet-poster i bakgrunden, samtidigt som Ni kan skriva CSS-liknande syntax med mallsträngar (använd enkla citattecken inuti, inte backticks med interpolering för statiska stilar). Det stöder även dynamisk stilformatering baserad på props med fullständigt TypeScript-stöd. Många team föredrar det eftersom det ger en välbekant CSS-upplevelse.
import styled from 'styled-components/native';
// Define styled components
const Card = styled.View`
background-color: #fff;
border-radius: 12px;
padding: 16px;
margin-bottom: 12px;
elevation: 3;
`;
const Title = styled.Text`
font-size: 18px;
font-weight: bold;
color: #222;
`;
export default function StyledCard({ title }) {
return (
<Card>
<Title>{title}</Title>
</Card>
);
}Snabbtest
Testa Era kunskaper om koncepten inom React Native Mobile Development från den här lektionen.
Sammanfattning av lektionen
I den här lektionen har du lärt dig att StyleSheet.create är effektivare än infogade objekt eftersom stilar skickas som ID:n i stället för som fullständiga objekt, att stilarrayer slår samman flera stilobjekt där senare poster har företräde, och att useColorScheme möjliggör styling som tar hänsyn till mörkt läge. Nästa steg är att utforska Flexbox-riktning, justifyContent och alignItems för full kontroll över layouten.
Lär dig JavaScript med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 30
- Lektioner
- 120
Vanliga frågor
Är lektionen ”StyleSheet.create och inline-stilar” gratis?
Ja – du kan läsa vilka 3 lektioner som helst i lärvägen React Native Academy, inklusive ”StyleSheet.create och inline-stilar”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i React Native Academy innehåller totalt 4 lektioner.
Vad lär jag mig i ”StyleSheet.create och inline-stilar”?
Skapa stilobjekt med StyleSheet.create för bättre prestanda, jämför dem med inline-stilar och använd flera stilar med hjälp av arrayer. Ni övar på React Native Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig React Native Academy?
Du behöver inga förkunskaper. Utbildningen i React Native Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.
Hur lång tid tar lektionen ”StyleSheet.create och inline-stilar”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här React Native Academy-lektionen?
Ja. Varje React Native Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- StyleSheet.create och inline-stilar
- Flexbox-riktning, JustifyContent och AlignItems
- flex, flexGrow och responsiv storlek
- Bygga ett responsivt kortnät